@riffdb/better-auth 0.2.0 → 0.2.1

package/generated/go/client.go

@@ -4,14 +4,15 @@ package riffdb_better_auth_core
 import (
 	"context"
 	"errors"
+	"sync"
 
 	riffdb "riffdb.dev/application"
 )
 
-const QueryModuleHash = "18cfd99921406e15722f3ac45867d3fbe0cebd4f2ecdd86c0ba099547c58cd91"
+const QueryModuleHash = "8dff3a38f6c0a915d7653e7571a2ef5795a89b452990d705f38fe0ac93b5ad9a"
 const ContractLineage = "RiffDBBetterAuthCore"
 const ContractVersion uint64 = 1
-const ContractBundleHash = "11c5a37724f40b92bf10b195e6a66ef30037f73f3df79a98e4c4ed1076883d2e"
+const ContractBundleHash = "74fd255eefcf04f0b054dbb6c4a0bed43a7312d82f7755687c9229ee3206ddfc"
 
 type QuerySecretOutput struct { Query string; Entity string; Field string }
 
@@ -372,6 +373,32 @@ func (FindActiveSessionsByUserIdFound) String() string { return "FindActiveSessi
 func (FindActiveSessionsByUserIdFound) GoString() string { return "FindActiveSessionsByUserIdFound{<secret outputs redacted>}" }
 
 func UnwrapFindActiveSessionsByUserIdFound(value FindActiveSessionsByUserIdResult) (FindActiveSessionsByUserIdFound, error) { if branch, ok := value.(FindActiveSessionsByUserIdFound); ok { return branch, nil }; return FindActiveSessionsByUserIdFound{}, errors.New("expected FindActiveSessionsByUserId outcome found") }
+var FindCredentialAccountSecretOutputs = []QuerySecretOutput{
+	{Query: "FindCredentialAccount", Entity: "Account", Field: "access_token"},
+	{Query: "FindCredentialAccount", Entity: "Account", Field: "refresh_token"},
+	{Query: "FindCredentialAccount", Entity: "Account", Field: "id_token"},
+	{Query: "FindCredentialAccount", Entity: "Account", Field: "password"},
+}
+
+type FindCredentialAccountParams struct {
+	OrganizationId string
+	UserId string
+	AccountId string
+	ProviderId string
+}
+
+type FindCredentialAccountResult interface { isFindCredentialAccountResult() }
+type FindCredentialAccountFound struct {
+	Outcome string
+	Accounts []struct { OrganizationId string; UserId string; Id string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; IdToken *string; Password *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }
+}
+func (FindCredentialAccountFound) isFindCredentialAccountResult() {}
+func IsFindCredentialAccountFound(value FindCredentialAccountResult) (FindCredentialAccountFound, bool) { branch, ok := value.(FindCredentialAccountFound); return branch, ok }
+
+func (FindCredentialAccountFound) String() string { return "FindCredentialAccountFound{<secret outputs redacted>}" }
+func (FindCredentialAccountFound) GoString() string { return "FindCredentialAccountFound{<secret outputs redacted>}" }
+
+func UnwrapFindCredentialAccountFound(value FindCredentialAccountResult) (FindCredentialAccountFound, error) { if branch, ok := value.(FindCredentialAccountFound); ok { return branch, nil }; return FindCredentialAccountFound{}, errors.New("expected FindCredentialAccount outcome found") }
 type FindExpiredVerificationIdsParams struct {
 	OrganizationId string
 	ExpiresBefore riffdb.Instant
@@ -629,6 +656,31 @@ type ConsumeVerificationSetVerificationConsumeMissing struct {
 func (ConsumeVerificationSetVerificationConsumeMissing) isConsumeVerificationSetOutcome() {}
 func IsConsumeVerificationSetVerificationConsumeMissing(value ConsumeVerificationSetOutcome) (ConsumeVerificationSetVerificationConsumeMissing, bool) { branch, ok := value.(ConsumeVerificationSetVerificationConsumeMissing); return branch, ok }
 
+type ConsumeVerificationSnapshotInput struct {
+	RequestId string
+	OrganizationId string
+	VerificationId string
+	ExpectedRevision uint64
+}
+type ConsumeVerificationSnapshotOutcome interface { isConsumeVerificationSnapshotOutcome() }
+type ConsumeVerificationSnapshotVerificationConsumed struct {
+	Outcome string
+}
+func (ConsumeVerificationSnapshotVerificationConsumed) isConsumeVerificationSnapshotOutcome() {}
+func IsConsumeVerificationSnapshotVerificationConsumed(value ConsumeVerificationSnapshotOutcome) (ConsumeVerificationSnapshotVerificationConsumed, bool) { branch, ok := value.(ConsumeVerificationSnapshotVerificationConsumed); return branch, ok }
+
+type ConsumeVerificationSnapshotVerificationConsumeStale struct {
+	Outcome string
+}
+func (ConsumeVerificationSnapshotVerificationConsumeStale) isConsumeVerificationSnapshotOutcome() {}
+func IsConsumeVerificationSnapshotVerificationConsumeStale(value ConsumeVerificationSnapshotOutcome) (ConsumeVerificationSnapshotVerificationConsumeStale, bool) { branch, ok := value.(ConsumeVerificationSnapshotVerificationConsumeStale); return branch, ok }
+
+type ConsumeVerificationSnapshotVerificationConsumeMissing struct {
+	Outcome string
+}
+func (ConsumeVerificationSnapshotVerificationConsumeMissing) isConsumeVerificationSnapshotOutcome() {}
+func IsConsumeVerificationSnapshotVerificationConsumeMissing(value ConsumeVerificationSnapshotOutcome) (ConsumeVerificationSnapshotVerificationConsumeMissing, bool) { branch, ok := value.(ConsumeVerificationSnapshotVerificationConsumeMissing); return branch, ok }
+
 type CreateAccountInput struct {
 	Id string
 	Scope *string
@@ -914,6 +966,55 @@ type DeleteVerificationVerificationMissing struct {
 func (DeleteVerificationVerificationMissing) isDeleteVerificationOutcome() {}
 func IsDeleteVerificationVerificationMissing(value DeleteVerificationOutcome) (DeleteVerificationVerificationMissing, bool) { branch, ok := value.(DeleteVerificationVerificationMissing); return branch, ok }
 
+type ResetCredentialPasswordInput struct {
+	UserId string
+	Password string
+	AccountId string
+	RequestId string
+	UpdatedAt riffdb.Instant
+	OrganizationId string
+	AccountRevision uint64
+	VerificationIds []string
+	ExternalAccountId string
+	VerificationRevision uint64
+}
+type ResetCredentialPasswordOutcome interface { isResetCredentialPasswordOutcome() }
+type ResetCredentialPasswordPasswordAccountStale struct {
+	Outcome string
+}
+func (ResetCredentialPasswordPasswordAccountStale) isResetCredentialPasswordOutcome() {}
+func IsResetCredentialPasswordPasswordAccountStale(value ResetCredentialPasswordOutcome) (ResetCredentialPasswordPasswordAccountStale, bool) { branch, ok := value.(ResetCredentialPasswordPasswordAccountStale); return branch, ok }
+
+type ResetCredentialPasswordPasswordAccountMissing struct {
+	Outcome string
+}
+func (ResetCredentialPasswordPasswordAccountMissing) isResetCredentialPasswordOutcome() {}
+func IsResetCredentialPasswordPasswordAccountMissing(value ResetCredentialPasswordOutcome) (ResetCredentialPasswordPasswordAccountMissing, bool) { branch, ok := value.(ResetCredentialPasswordPasswordAccountMissing); return branch, ok }
+
+type ResetCredentialPasswordCredentialPasswordReset struct {
+	Outcome string
+}
+func (ResetCredentialPasswordCredentialPasswordReset) isResetCredentialPasswordOutcome() {}
+func IsResetCredentialPasswordCredentialPasswordReset(value ResetCredentialPasswordOutcome) (ResetCredentialPasswordCredentialPasswordReset, bool) { branch, ok := value.(ResetCredentialPasswordCredentialPasswordReset); return branch, ok }
+
+type ResetCredentialPasswordPasswordProviderMismatch struct {
+	Outcome string
+}
+func (ResetCredentialPasswordPasswordProviderMismatch) isResetCredentialPasswordOutcome() {}
+func IsResetCredentialPasswordPasswordProviderMismatch(value ResetCredentialPasswordOutcome) (ResetCredentialPasswordPasswordProviderMismatch, bool) { branch, ok := value.(ResetCredentialPasswordPasswordProviderMismatch); return branch, ok }
+
+type ResetCredentialPasswordVerificationConsumeStale struct {
+	Outcome string
+}
+func (ResetCredentialPasswordVerificationConsumeStale) isResetCredentialPasswordOutcome() {}
+func IsResetCredentialPasswordVerificationConsumeStale(value ResetCredentialPasswordOutcome) (ResetCredentialPasswordVerificationConsumeStale, bool) { branch, ok := value.(ResetCredentialPasswordVerificationConsumeStale); return branch, ok }
+
+type ResetCredentialPasswordVerificationConsumeMissing struct {
+	Outcome string
+}
+func (ResetCredentialPasswordVerificationConsumeMissing) isResetCredentialPasswordOutcome() {}
+func IsResetCredentialPasswordVerificationConsumeMissing(value ResetCredentialPasswordOutcome) (ResetCredentialPasswordVerificationConsumeMissing, bool) { branch, ok := value.(ResetCredentialPasswordVerificationConsumeMissing); return branch, ok }
+
 type UpdateAccountInput struct {
 	Scope *string
 	UserId string
@@ -981,6 +1082,41 @@ type UpdateAccountPasswordsPasswordProviderMismatch struct {
 func (UpdateAccountPasswordsPasswordProviderMismatch) isUpdateAccountPasswordsOutcome() {}
 func IsUpdateAccountPasswordsPasswordProviderMismatch(value UpdateAccountPasswordsOutcome) (UpdateAccountPasswordsPasswordProviderMismatch, bool) { branch, ok := value.(UpdateAccountPasswordsPasswordProviderMismatch); return branch, ok }
 
+type UpdateCredentialPasswordInput struct {
+	UserId string
+	Password string
+	AccountId string
+	RequestId string
+	UpdatedAt riffdb.Instant
+	OrganizationId string
+	ExpectedRevision uint64
+	ExternalAccountId string
+}
+type UpdateCredentialPasswordOutcome interface { isUpdateCredentialPasswordOutcome() }
+type UpdateCredentialPasswordPasswordAccountStale struct {
+	Outcome string
+}
+func (UpdateCredentialPasswordPasswordAccountStale) isUpdateCredentialPasswordOutcome() {}
+func IsUpdateCredentialPasswordPasswordAccountStale(value UpdateCredentialPasswordOutcome) (UpdateCredentialPasswordPasswordAccountStale, bool) { branch, ok := value.(UpdateCredentialPasswordPasswordAccountStale); return branch, ok }
+
+type UpdateCredentialPasswordPasswordAccountMissing struct {
+	Outcome string
+}
+func (UpdateCredentialPasswordPasswordAccountMissing) isUpdateCredentialPasswordOutcome() {}
+func IsUpdateCredentialPasswordPasswordAccountMissing(value UpdateCredentialPasswordOutcome) (UpdateCredentialPasswordPasswordAccountMissing, bool) { branch, ok := value.(UpdateCredentialPasswordPasswordAccountMissing); return branch, ok }
+
+type UpdateCredentialPasswordPasswordProviderMismatch struct {
+	Outcome string
+}
+func (UpdateCredentialPasswordPasswordProviderMismatch) isUpdateCredentialPasswordOutcome() {}
+func IsUpdateCredentialPasswordPasswordProviderMismatch(value UpdateCredentialPasswordOutcome) (UpdateCredentialPasswordPasswordProviderMismatch, bool) { branch, ok := value.(UpdateCredentialPasswordPasswordProviderMismatch); return branch, ok }
+
+type UpdateCredentialPasswordCredentialPasswordUpdated struct {
+	Outcome string
+}
+func (UpdateCredentialPasswordCredentialPasswordUpdated) isUpdateCredentialPasswordOutcome() {}
+func IsUpdateCredentialPasswordCredentialPasswordUpdated(value UpdateCredentialPasswordOutcome) (UpdateCredentialPasswordCredentialPasswordUpdated, bool) { branch, ok := value.(UpdateCredentialPasswordCredentialPasswordUpdated); return branch, ok }
+
 type UpdateSessionInput struct {
 	UserId string
 	ExpiresAt riffdb.Instant
@@ -1070,12 +1206,17 @@ func (UpdateVerificationVerificationUpdateMissing) isUpdateVerificationOutcome()
 func IsUpdateVerificationVerificationUpdateMissing(value UpdateVerificationOutcome) (UpdateVerificationVerificationUpdateMissing, bool) { branch, ok := value.(UpdateVerificationVerificationUpdateMissing); return branch, ok }
 
 const DefaultCommandAttempts uint32 = 3
-type Client struct { session *riffdb.Session; commandAttempts uint32; readAfterCommit *uint64; trackCausalWrites bool }
+type Client struct { session *riffdb.Session; commandAttempts uint32; causalMu sync.Mutex; readAfterCommit *uint64; trackCausalWrites bool }
 
 func NewClient(session *riffdb.Session, commandAttempts ...uint32) (*Client, error) { attempts := DefaultCommandAttempts; if len(commandAttempts) > 1 { return nil, errors.New("invalid generated RiffDB client configuration") } else if len(commandAttempts) == 1 { attempts = commandAttempts[0] }; if session == nil || attempts < 1 || attempts > 10 { return nil, errors.New("invalid generated RiffDB client configuration") }; return &Client{session: session, commandAttempts: attempts, trackCausalWrites: true}, nil }
+func DriverIdentity(role string, database ...string) riffdb.Identity { var db string; if len(database) > 0 { db = database[0] }; return riffdb.Identity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, Role: role, Database: db} }
+func Connect(ctx context.Context, socketPath string, role string, database ...string) (*Client, error) { if len(database) > 1 { return nil, errors.New("invalid generated RiffDB client configuration") }; session, err := riffdb.Connect(ctx, socketPath, DriverIdentity(role, database...)); if err != nil { return nil, err }; return NewClient(session) }
+func ConnectFromEnv(ctx context.Context, prefix ...string) (*Client, error) { if len(prefix) > 1 { return nil, errors.New("invalid generated RiffDB client configuration") }; var envPrefix string; if len(prefix) == 1 { envPrefix = prefix[0] }; session, err := riffdb.ConnectFromEnv(ctx, riffdb.Identity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash}, envPrefix); if err != nil { return nil, err }; return NewClient(session) }
+func (client *Client) Close() error { if client == nil || client.session == nil { return nil }; return client.session.Close() }
 func (client *Client) WithReadAfterCommit(commitSequence *uint64) *Client { var copied *uint64; if commitSequence != nil { value := *commitSequence; copied = &value }; return &Client{session: client.session, commandAttempts: client.commandAttempts, readAfterCommit: copied, trackCausalWrites: client.trackCausalWrites} }
-func (client *Client) CausalSession(initialCommitSequence ...uint64) *Client { var copied *uint64; if len(initialCommitSequence) > 0 { value := initialCommitSequence[0]; copied = &value } else if client.readAfterCommit != nil { value := *client.readAfterCommit; copied = &value }; return &Client{session: client.session, commandAttempts: client.commandAttempts, readAfterCommit: copied, trackCausalWrites: true} }
-func (client *Client) LastCommitSequence() *uint64 { if client.readAfterCommit == nil { return nil }; value := *client.readAfterCommit; return &value }
+func (client *Client) CausalSession(initialCommitSequence ...uint64) *Client { var copied *uint64; if len(initialCommitSequence) > 0 { value := initialCommitSequence[0]; copied = &value } else { copied = client.LastCommitSequence() }; return &Client{session: client.session, commandAttempts: client.commandAttempts, readAfterCommit: copied, trackCausalWrites: true} }
+func (client *Client) LastCommitSequence() *uint64 { client.causalMu.Lock(); defer client.causalMu.Unlock(); if client.readAfterCommit == nil { return nil }; value := *client.readAfterCommit; return &value }
+func (client *Client) observeCommit(commitSequence *uint64) { if !client.trackCausalWrites || commitSequence == nil || *commitSequence == 0 { return }; client.causalMu.Lock(); if client.readAfterCommit == nil || *commitSequence > *client.readAfterCommit { value := *commitSequence; client.readAfterCommit = &value }; client.causalMu.Unlock() }
 
 func encodeUser(value User) riffdb.Value { return riffdb.Record(map[string]riffdb.Value{
 	"name": riffdb.String(value.Name),
@@ -1200,15 +1341,15 @@ raw, err = requiredField(fields, "organization_id"); if err != nil { return resu
 raw, err = requiredField(fields, "expected_revision"); if err != nil { return result, err }; result.ExpectedRevision, err = riffdb.U64Value(raw); if err != nil { return result, err }
 return result, nil }
 
-const AdminUsersAllEmailAscQueryPlanHash = "ea5056df116418329d03bc536a195247148360378e11444c10e7ca37df54c547"
-var AdminUsersAllEmailAscOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_all_email_asc", InputSchemaHash: "b6bd739e8b61fb38bfaa049f1dc5adb7bd02deec468a04a3964606bda534dd60"}
+const AdminUsersAllEmailAscQueryPlanHash = "056edbaabe43e1dc95f1f6af9838747f54d927a90d5bc9f2be045ae266d107d3"
+var AdminUsersAllEmailAscOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_all_email_asc", InputSchemaHash: "6f126f498c06a6648d15a6403e27e29890892d64f010ef3d89b3470124ebdd5f"}
 func decodeAdminUsersAllEmailAscResult(value riffdb.Value) (AdminUsersAllEmailAscResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := AdminUsersAllEmailAscFound{Outcome: outcome}
 raw, err = requiredField(fields, "users"); if err != nil { return nil, err }; result.Users, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "organization_id"); if err != nil { return result, err }; result.OrganizationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "name"); if err != nil { return result, err }; result.Name, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email"); if err != nil { return result, err }; result.Email, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email_verified"); if err != nil { return result, err }; result.EmailVerified, err = riffdb.BoolValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "image"); if err != nil { return result, err }; result.Image, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 raw, err = requiredField(fields, "total"); if err != nil { return nil, err }; result.Total, err = func() (struct { Value uint64 }, error) { fields, err := riffdb.RecordFields(raw); if err != nil { return struct { Value uint64 }{}, err }; var result struct { Value uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "value"); if err != nil { return result, err }; result.Value, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }(); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) AdminUsersAllEmailAsc(ctx context.Context, parameters AdminUsersAllEmailAscParams, optionsList ...QueryOptions) (QueryResult[AdminUsersAllEmailAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersAllEmailAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) AdminUsersAllEmailAsc(ctx context.Context, parameters AdminUsersAllEmailAscParams, optionsList ...QueryOptions) (QueryResult[AdminUsersAllEmailAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersAllEmailAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.Limit != nil && (*parameters.Limit == 0 || uint64(*parameters.Limit) > 100) { return QueryResult[AdminUsersAllEmailAscResult]{}, errors.New("limit must be from 1 through 100") }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["minimum_email"] = riffdb.String(parameters.MinimumEmail)
@@ -1218,15 +1359,15 @@ if parameters.Offset != nil { input["offset"] = riffdb.U64(*parameters.Offset) }
 response, err := client.session.Invoke(ctx, AdminUsersAllEmailAscOperation, input, options); if err != nil { return QueryResult[AdminUsersAllEmailAscResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[AdminUsersAllEmailAscResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeAdminUsersAllEmailAscResult(response.Value); if err != nil { return QueryResult[AdminUsersAllEmailAscResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "AdminUsersAllEmailAsc", PlanHash: AdminUsersAllEmailAscQueryPlanHash}; return QueryResult[AdminUsersAllEmailAscResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) AdminUsersAllEmailAscAfterCommit(ctx context.Context, parameters AdminUsersAllEmailAscParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[AdminUsersAllEmailAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersAllEmailAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.AdminUsersAllEmailAsc(ctx, parameters, options) }
 
-const AdminUsersContainsAscQueryPlanHash = "56132d4a48f43731e36b69e0fe922d67491bc0ad611375fbc3d372a840b739df"
-var AdminUsersContainsAscOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_contains_asc", InputSchemaHash: "8c636b7707e3c1766fa6fb54c24a8309c800ccb44fe83dc5d378f907ff87e823"}
+const AdminUsersContainsAscQueryPlanHash = "b64d213477dd2275d98422a6c3460b0cae932dd96255fe9d565005e8afa37fc4"
+var AdminUsersContainsAscOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_contains_asc", InputSchemaHash: "9ffe6e4d932b3572aefb9d58255932828b4b85445b0312722b3c8be772bdd11b"}
 func decodeAdminUsersContainsAscResult(value riffdb.Value) (AdminUsersContainsAscResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := AdminUsersContainsAscFound{Outcome: outcome}
 raw, err = requiredField(fields, "users"); if err != nil { return nil, err }; result.Users, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "organization_id"); if err != nil { return result, err }; result.OrganizationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "name"); if err != nil { return result, err }; result.Name, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email"); if err != nil { return result, err }; result.Email, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email_verified"); if err != nil { return result, err }; result.EmailVerified, err = riffdb.BoolValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "image"); if err != nil { return result, err }; result.Image, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 raw, err = requiredField(fields, "total"); if err != nil { return nil, err }; result.Total, err = func() (struct { Value uint64 }, error) { fields, err := riffdb.RecordFields(raw); if err != nil { return struct { Value uint64 }{}, err }; var result struct { Value uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "value"); if err != nil { return result, err }; result.Value, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }(); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) AdminUsersContainsAsc(ctx context.Context, parameters AdminUsersContainsAscParams, optionsList ...QueryOptions) (QueryResult[AdminUsersContainsAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersContainsAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) AdminUsersContainsAsc(ctx context.Context, parameters AdminUsersContainsAscParams, optionsList ...QueryOptions) (QueryResult[AdminUsersContainsAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersContainsAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.Limit != nil && (*parameters.Limit == 0 || uint64(*parameters.Limit) > 100) { return QueryResult[AdminUsersContainsAscResult]{}, errors.New("limit must be from 1 through 100") }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["needle"] = riffdb.String(parameters.Needle)
@@ -1236,15 +1377,15 @@ if parameters.Offset != nil { input["offset"] = riffdb.U64(*parameters.Offset) }
 response, err := client.session.Invoke(ctx, AdminUsersContainsAscOperation, input, options); if err != nil { return QueryResult[AdminUsersContainsAscResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[AdminUsersContainsAscResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeAdminUsersContainsAscResult(response.Value); if err != nil { return QueryResult[AdminUsersContainsAscResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "AdminUsersContainsAsc", PlanHash: AdminUsersContainsAscQueryPlanHash}; return QueryResult[AdminUsersContainsAscResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) AdminUsersContainsAscAfterCommit(ctx context.Context, parameters AdminUsersContainsAscParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[AdminUsersContainsAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersContainsAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.AdminUsersContainsAsc(ctx, parameters, options) }
 
-const AdminUsersContainsDescQueryPlanHash = "470b720e68aa2261d902378ebc7fb1ce5be51582761672da7ecb87bece977f0f"
-var AdminUsersContainsDescOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_contains_desc", InputSchemaHash: "8c636b7707e3c1766fa6fb54c24a8309c800ccb44fe83dc5d378f907ff87e823"}
+const AdminUsersContainsDescQueryPlanHash = "57aba8cf311c301e985adc324f97b4d963a38e6efa6058a82e248854d75f2f05"
+var AdminUsersContainsDescOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_contains_desc", InputSchemaHash: "9ffe6e4d932b3572aefb9d58255932828b4b85445b0312722b3c8be772bdd11b"}
 func decodeAdminUsersContainsDescResult(value riffdb.Value) (AdminUsersContainsDescResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := AdminUsersContainsDescFound{Outcome: outcome}
 raw, err = requiredField(fields, "users"); if err != nil { return nil, err }; result.Users, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "organization_id"); if err != nil { return result, err }; result.OrganizationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "name"); if err != nil { return result, err }; result.Name, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email"); if err != nil { return result, err }; result.Email, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email_verified"); if err != nil { return result, err }; result.EmailVerified, err = riffdb.BoolValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "image"); if err != nil { return result, err }; result.Image, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 raw, err = requiredField(fields, "total"); if err != nil { return nil, err }; result.Total, err = func() (struct { Value uint64 }, error) { fields, err := riffdb.RecordFields(raw); if err != nil { return struct { Value uint64 }{}, err }; var result struct { Value uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "value"); if err != nil { return result, err }; result.Value, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }(); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) AdminUsersContainsDesc(ctx context.Context, parameters AdminUsersContainsDescParams, optionsList ...QueryOptions) (QueryResult[AdminUsersContainsDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersContainsDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) AdminUsersContainsDesc(ctx context.Context, parameters AdminUsersContainsDescParams, optionsList ...QueryOptions) (QueryResult[AdminUsersContainsDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersContainsDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.Limit != nil && (*parameters.Limit == 0 || uint64(*parameters.Limit) > 100) { return QueryResult[AdminUsersContainsDescResult]{}, errors.New("limit must be from 1 through 100") }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["needle"] = riffdb.String(parameters.Needle)
@@ -1254,15 +1395,15 @@ if parameters.Offset != nil { input["offset"] = riffdb.U64(*parameters.Offset) }
 response, err := client.session.Invoke(ctx, AdminUsersContainsDescOperation, input, options); if err != nil { return QueryResult[AdminUsersContainsDescResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[AdminUsersContainsDescResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeAdminUsersContainsDescResult(response.Value); if err != nil { return QueryResult[AdminUsersContainsDescResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "AdminUsersContainsDesc", PlanHash: AdminUsersContainsDescQueryPlanHash}; return QueryResult[AdminUsersContainsDescResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) AdminUsersContainsDescAfterCommit(ctx context.Context, parameters AdminUsersContainsDescParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[AdminUsersContainsDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersContainsDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.AdminUsersContainsDesc(ctx, parameters, options) }
 
-const AdminUsersEmailContainsCreatedDescQueryPlanHash = "51def4488ff2a35fee0c5d7f267daaca11e60a03521be0fdaf8923c5486c5485"
-var AdminUsersEmailContainsCreatedDescOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_email_contains_created_desc", InputSchemaHash: "8c636b7707e3c1766fa6fb54c24a8309c800ccb44fe83dc5d378f907ff87e823"}
+const AdminUsersEmailContainsCreatedDescQueryPlanHash = "7aede9eda624f5b4eb4280ca7b8a1421466ce30091177c9abab4f125987eb4ff"
+var AdminUsersEmailContainsCreatedDescOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_email_contains_created_desc", InputSchemaHash: "9ffe6e4d932b3572aefb9d58255932828b4b85445b0312722b3c8be772bdd11b"}
 func decodeAdminUsersEmailContainsCreatedDescResult(value riffdb.Value) (AdminUsersEmailContainsCreatedDescResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := AdminUsersEmailContainsCreatedDescFound{Outcome: outcome}
 raw, err = requiredField(fields, "users"); if err != nil { return nil, err }; result.Users, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "organization_id"); if err != nil { return result, err }; result.OrganizationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "name"); if err != nil { return result, err }; result.Name, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email"); if err != nil { return result, err }; result.Email, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email_verified"); if err != nil { return result, err }; result.EmailVerified, err = riffdb.BoolValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "image"); if err != nil { return result, err }; result.Image, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 raw, err = requiredField(fields, "total"); if err != nil { return nil, err }; result.Total, err = func() (struct { Value uint64 }, error) { fields, err := riffdb.RecordFields(raw); if err != nil { return struct { Value uint64 }{}, err }; var result struct { Value uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "value"); if err != nil { return result, err }; result.Value, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }(); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) AdminUsersEmailContainsCreatedDesc(ctx context.Context, parameters AdminUsersEmailContainsCreatedDescParams, optionsList ...QueryOptions) (QueryResult[AdminUsersEmailContainsCreatedDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEmailContainsCreatedDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) AdminUsersEmailContainsCreatedDesc(ctx context.Context, parameters AdminUsersEmailContainsCreatedDescParams, optionsList ...QueryOptions) (QueryResult[AdminUsersEmailContainsCreatedDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEmailContainsCreatedDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.Limit != nil && (*parameters.Limit == 0 || uint64(*parameters.Limit) > 100) { return QueryResult[AdminUsersEmailContainsCreatedDescResult]{}, errors.New("limit must be from 1 through 100") }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["needle"] = riffdb.String(parameters.Needle)
@@ -1272,15 +1413,15 @@ if parameters.Offset != nil { input["offset"] = riffdb.U64(*parameters.Offset) }
 response, err := client.session.Invoke(ctx, AdminUsersEmailContainsCreatedDescOperation, input, options); if err != nil { return QueryResult[AdminUsersEmailContainsCreatedDescResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[AdminUsersEmailContainsCreatedDescResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeAdminUsersEmailContainsCreatedDescResult(response.Value); if err != nil { return QueryResult[AdminUsersEmailContainsCreatedDescResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "AdminUsersEmailContainsCreatedDesc", PlanHash: AdminUsersEmailContainsCreatedDescQueryPlanHash}; return QueryResult[AdminUsersEmailContainsCreatedDescResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) AdminUsersEmailContainsCreatedDescAfterCommit(ctx context.Context, parameters AdminUsersEmailContainsCreatedDescParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[AdminUsersEmailContainsCreatedDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEmailContainsCreatedDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.AdminUsersEmailContainsCreatedDesc(ctx, parameters, options) }
 
-const AdminUsersEmailContainsImageAscQueryPlanHash = "fd5dc86099567113dcce8ef61c280b22f35a2c3b9e6fc592f0bcfaded4008f80"
-var AdminUsersEmailContainsImageAscOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_email_contains_image_asc", InputSchemaHash: "8c636b7707e3c1766fa6fb54c24a8309c800ccb44fe83dc5d378f907ff87e823"}
+const AdminUsersEmailContainsImageAscQueryPlanHash = "453cb6c81f506a1f0ac99bed3cc85da59176d2cb83597d5812d771683a60cb4c"
+var AdminUsersEmailContainsImageAscOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_email_contains_image_asc", InputSchemaHash: "9ffe6e4d932b3572aefb9d58255932828b4b85445b0312722b3c8be772bdd11b"}
 func decodeAdminUsersEmailContainsImageAscResult(value riffdb.Value) (AdminUsersEmailContainsImageAscResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := AdminUsersEmailContainsImageAscFound{Outcome: outcome}
 raw, err = requiredField(fields, "users"); if err != nil { return nil, err }; result.Users, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "organization_id"); if err != nil { return result, err }; result.OrganizationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "name"); if err != nil { return result, err }; result.Name, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email"); if err != nil { return result, err }; result.Email, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email_verified"); if err != nil { return result, err }; result.EmailVerified, err = riffdb.BoolValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "image"); if err != nil { return result, err }; result.Image, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 raw, err = requiredField(fields, "total"); if err != nil { return nil, err }; result.Total, err = func() (struct { Value uint64 }, error) { fields, err := riffdb.RecordFields(raw); if err != nil { return struct { Value uint64 }{}, err }; var result struct { Value uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "value"); if err != nil { return result, err }; result.Value, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }(); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) AdminUsersEmailContainsImageAsc(ctx context.Context, parameters AdminUsersEmailContainsImageAscParams, optionsList ...QueryOptions) (QueryResult[AdminUsersEmailContainsImageAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEmailContainsImageAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) AdminUsersEmailContainsImageAsc(ctx context.Context, parameters AdminUsersEmailContainsImageAscParams, optionsList ...QueryOptions) (QueryResult[AdminUsersEmailContainsImageAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEmailContainsImageAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.Limit != nil && (*parameters.Limit == 0 || uint64(*parameters.Limit) > 100) { return QueryResult[AdminUsersEmailContainsImageAscResult]{}, errors.New("limit must be from 1 through 100") }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["needle"] = riffdb.String(parameters.Needle)
@@ -1290,15 +1431,15 @@ if parameters.Offset != nil { input["offset"] = riffdb.U64(*parameters.Offset) }
 response, err := client.session.Invoke(ctx, AdminUsersEmailContainsImageAscOperation, input, options); if err != nil { return QueryResult[AdminUsersEmailContainsImageAscResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[AdminUsersEmailContainsImageAscResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeAdminUsersEmailContainsImageAscResult(response.Value); if err != nil { return QueryResult[AdminUsersEmailContainsImageAscResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "AdminUsersEmailContainsImageAsc", PlanHash: AdminUsersEmailContainsImageAscQueryPlanHash}; return QueryResult[AdminUsersEmailContainsImageAscResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) AdminUsersEmailContainsImageAscAfterCommit(ctx context.Context, parameters AdminUsersEmailContainsImageAscParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[AdminUsersEmailContainsImageAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEmailContainsImageAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.AdminUsersEmailContainsImageAsc(ctx, parameters, options) }
 
-const AdminUsersEndsWithAscQueryPlanHash = "a83229249df961abbc113e7b808af6beca7ca915835ddcd06cd5c28bb7d3c920"
-var AdminUsersEndsWithAscOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_ends_with_asc", InputSchemaHash: "8c636b7707e3c1766fa6fb54c24a8309c800ccb44fe83dc5d378f907ff87e823"}
+const AdminUsersEndsWithAscQueryPlanHash = "924c7acfdcf3f7970917ac611b6eafc9175ac69f735d9e1cc01414fcc6f0e696"
+var AdminUsersEndsWithAscOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_ends_with_asc", InputSchemaHash: "9ffe6e4d932b3572aefb9d58255932828b4b85445b0312722b3c8be772bdd11b"}
 func decodeAdminUsersEndsWithAscResult(value riffdb.Value) (AdminUsersEndsWithAscResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := AdminUsersEndsWithAscFound{Outcome: outcome}
 raw, err = requiredField(fields, "users"); if err != nil { return nil, err }; result.Users, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "organization_id"); if err != nil { return result, err }; result.OrganizationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "name"); if err != nil { return result, err }; result.Name, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email"); if err != nil { return result, err }; result.Email, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email_verified"); if err != nil { return result, err }; result.EmailVerified, err = riffdb.BoolValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "image"); if err != nil { return result, err }; result.Image, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 raw, err = requiredField(fields, "total"); if err != nil { return nil, err }; result.Total, err = func() (struct { Value uint64 }, error) { fields, err := riffdb.RecordFields(raw); if err != nil { return struct { Value uint64 }{}, err }; var result struct { Value uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "value"); if err != nil { return result, err }; result.Value, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }(); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) AdminUsersEndsWithAsc(ctx context.Context, parameters AdminUsersEndsWithAscParams, optionsList ...QueryOptions) (QueryResult[AdminUsersEndsWithAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEndsWithAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) AdminUsersEndsWithAsc(ctx context.Context, parameters AdminUsersEndsWithAscParams, optionsList ...QueryOptions) (QueryResult[AdminUsersEndsWithAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEndsWithAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.Limit != nil && (*parameters.Limit == 0 || uint64(*parameters.Limit) > 100) { return QueryResult[AdminUsersEndsWithAscResult]{}, errors.New("limit must be from 1 through 100") }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["needle"] = riffdb.String(parameters.Needle)
@@ -1308,15 +1449,15 @@ if parameters.Offset != nil { input["offset"] = riffdb.U64(*parameters.Offset) }
 response, err := client.session.Invoke(ctx, AdminUsersEndsWithAscOperation, input, options); if err != nil { return QueryResult[AdminUsersEndsWithAscResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[AdminUsersEndsWithAscResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeAdminUsersEndsWithAscResult(response.Value); if err != nil { return QueryResult[AdminUsersEndsWithAscResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "AdminUsersEndsWithAsc", PlanHash: AdminUsersEndsWithAscQueryPlanHash}; return QueryResult[AdminUsersEndsWithAscResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) AdminUsersEndsWithAscAfterCommit(ctx context.Context, parameters AdminUsersEndsWithAscParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[AdminUsersEndsWithAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEndsWithAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.AdminUsersEndsWithAsc(ctx, parameters, options) }
 
-const AdminUsersEndsWithDescQueryPlanHash = "ac6fdfacb6f36e2a68e36429171b5d8d502b2fd43f781d72541ece961f1da93c"
-var AdminUsersEndsWithDescOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_ends_with_desc", InputSchemaHash: "8c636b7707e3c1766fa6fb54c24a8309c800ccb44fe83dc5d378f907ff87e823"}
+const AdminUsersEndsWithDescQueryPlanHash = "cab8ad8456533e4ce97388948e4f703cac6f2eebb641b83a91c3b005ece7fffb"
+var AdminUsersEndsWithDescOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_ends_with_desc", InputSchemaHash: "9ffe6e4d932b3572aefb9d58255932828b4b85445b0312722b3c8be772bdd11b"}
 func decodeAdminUsersEndsWithDescResult(value riffdb.Value) (AdminUsersEndsWithDescResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := AdminUsersEndsWithDescFound{Outcome: outcome}
 raw, err = requiredField(fields, "users"); if err != nil { return nil, err }; result.Users, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "organization_id"); if err != nil { return result, err }; result.OrganizationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "name"); if err != nil { return result, err }; result.Name, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email"); if err != nil { return result, err }; result.Email, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email_verified"); if err != nil { return result, err }; result.EmailVerified, err = riffdb.BoolValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "image"); if err != nil { return result, err }; result.Image, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 raw, err = requiredField(fields, "total"); if err != nil { return nil, err }; result.Total, err = func() (struct { Value uint64 }, error) { fields, err := riffdb.RecordFields(raw); if err != nil { return struct { Value uint64 }{}, err }; var result struct { Value uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "value"); if err != nil { return result, err }; result.Value, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }(); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) AdminUsersEndsWithDesc(ctx context.Context, parameters AdminUsersEndsWithDescParams, optionsList ...QueryOptions) (QueryResult[AdminUsersEndsWithDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEndsWithDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) AdminUsersEndsWithDesc(ctx context.Context, parameters AdminUsersEndsWithDescParams, optionsList ...QueryOptions) (QueryResult[AdminUsersEndsWithDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEndsWithDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.Limit != nil && (*parameters.Limit == 0 || uint64(*parameters.Limit) > 100) { return QueryResult[AdminUsersEndsWithDescResult]{}, errors.New("limit must be from 1 through 100") }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["needle"] = riffdb.String(parameters.Needle)
@@ -1326,15 +1467,15 @@ if parameters.Offset != nil { input["offset"] = riffdb.U64(*parameters.Offset) }
 response, err := client.session.Invoke(ctx, AdminUsersEndsWithDescOperation, input, options); if err != nil { return QueryResult[AdminUsersEndsWithDescResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[AdminUsersEndsWithDescResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeAdminUsersEndsWithDescResult(response.Value); if err != nil { return QueryResult[AdminUsersEndsWithDescResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "AdminUsersEndsWithDesc", PlanHash: AdminUsersEndsWithDescQueryPlanHash}; return QueryResult[AdminUsersEndsWithDescResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) AdminUsersEndsWithDescAfterCommit(ctx context.Context, parameters AdminUsersEndsWithDescParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[AdminUsersEndsWithDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersEndsWithDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.AdminUsersEndsWithDesc(ctx, parameters, options) }
 
-const AdminUsersStartsWithAscQueryPlanHash = "e9594b9b9631b78e8cbd9a89c4a2f1b43cb40b62ef55bb18b704f790044b2332"
-var AdminUsersStartsWithAscOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_starts_with_asc", InputSchemaHash: "8c636b7707e3c1766fa6fb54c24a8309c800ccb44fe83dc5d378f907ff87e823"}
+const AdminUsersStartsWithAscQueryPlanHash = "add0aed3dbd0caea0de2857133a857d49eb7bfc0e031d117270cc873137da5ec"
+var AdminUsersStartsWithAscOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_starts_with_asc", InputSchemaHash: "9ffe6e4d932b3572aefb9d58255932828b4b85445b0312722b3c8be772bdd11b"}
 func decodeAdminUsersStartsWithAscResult(value riffdb.Value) (AdminUsersStartsWithAscResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := AdminUsersStartsWithAscFound{Outcome: outcome}
 raw, err = requiredField(fields, "users"); if err != nil { return nil, err }; result.Users, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "organization_id"); if err != nil { return result, err }; result.OrganizationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "name"); if err != nil { return result, err }; result.Name, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email"); if err != nil { return result, err }; result.Email, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email_verified"); if err != nil { return result, err }; result.EmailVerified, err = riffdb.BoolValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "image"); if err != nil { return result, err }; result.Image, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 raw, err = requiredField(fields, "total"); if err != nil { return nil, err }; result.Total, err = func() (struct { Value uint64 }, error) { fields, err := riffdb.RecordFields(raw); if err != nil { return struct { Value uint64 }{}, err }; var result struct { Value uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "value"); if err != nil { return result, err }; result.Value, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }(); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) AdminUsersStartsWithAsc(ctx context.Context, parameters AdminUsersStartsWithAscParams, optionsList ...QueryOptions) (QueryResult[AdminUsersStartsWithAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersStartsWithAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) AdminUsersStartsWithAsc(ctx context.Context, parameters AdminUsersStartsWithAscParams, optionsList ...QueryOptions) (QueryResult[AdminUsersStartsWithAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersStartsWithAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.Limit != nil && (*parameters.Limit == 0 || uint64(*parameters.Limit) > 100) { return QueryResult[AdminUsersStartsWithAscResult]{}, errors.New("limit must be from 1 through 100") }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["needle"] = riffdb.String(parameters.Needle)
@@ -1344,15 +1485,15 @@ if parameters.Offset != nil { input["offset"] = riffdb.U64(*parameters.Offset) }
 response, err := client.session.Invoke(ctx, AdminUsersStartsWithAscOperation, input, options); if err != nil { return QueryResult[AdminUsersStartsWithAscResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[AdminUsersStartsWithAscResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeAdminUsersStartsWithAscResult(response.Value); if err != nil { return QueryResult[AdminUsersStartsWithAscResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "AdminUsersStartsWithAsc", PlanHash: AdminUsersStartsWithAscQueryPlanHash}; return QueryResult[AdminUsersStartsWithAscResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) AdminUsersStartsWithAscAfterCommit(ctx context.Context, parameters AdminUsersStartsWithAscParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[AdminUsersStartsWithAscResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersStartsWithAscResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.AdminUsersStartsWithAsc(ctx, parameters, options) }
 
-const AdminUsersStartsWithDescQueryPlanHash = "1f52bcc4f1f3e778f33e3e47299009ce70d3f4c541d1bed35e6f953d0e79ffea"
-var AdminUsersStartsWithDescOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_starts_with_desc", InputSchemaHash: "8c636b7707e3c1766fa6fb54c24a8309c800ccb44fe83dc5d378f907ff87e823"}
+const AdminUsersStartsWithDescQueryPlanHash = "23c1561fb3956217e79d1b358be468e55c4021b887e927a4fb3c0484c92be872"
+var AdminUsersStartsWithDescOperation = riffdb.Operation{Name: "riffdb_better_auth_core_admin_users_starts_with_desc", InputSchemaHash: "9ffe6e4d932b3572aefb9d58255932828b4b85445b0312722b3c8be772bdd11b"}
 func decodeAdminUsersStartsWithDescResult(value riffdb.Value) (AdminUsersStartsWithDescResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := AdminUsersStartsWithDescFound{Outcome: outcome}
 raw, err = requiredField(fields, "users"); if err != nil { return nil, err }; result.Users, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { OrganizationId string; UserId string; Name string; Email string; EmailVerified bool; Image *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "organization_id"); if err != nil { return result, err }; result.OrganizationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "name"); if err != nil { return result, err }; result.Name, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email"); if err != nil { return result, err }; result.Email, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "email_verified"); if err != nil { return result, err }; result.EmailVerified, err = riffdb.BoolValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "image"); if err != nil { return result, err }; result.Image, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 raw, err = requiredField(fields, "total"); if err != nil { return nil, err }; result.Total, err = func() (struct { Value uint64 }, error) { fields, err := riffdb.RecordFields(raw); if err != nil { return struct { Value uint64 }{}, err }; var result struct { Value uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "value"); if err != nil { return result, err }; result.Value, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }(); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) AdminUsersStartsWithDesc(ctx context.Context, parameters AdminUsersStartsWithDescParams, optionsList ...QueryOptions) (QueryResult[AdminUsersStartsWithDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersStartsWithDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) AdminUsersStartsWithDesc(ctx context.Context, parameters AdminUsersStartsWithDescParams, optionsList ...QueryOptions) (QueryResult[AdminUsersStartsWithDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersStartsWithDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.Limit != nil && (*parameters.Limit == 0 || uint64(*parameters.Limit) > 100) { return QueryResult[AdminUsersStartsWithDescResult]{}, errors.New("limit must be from 1 through 100") }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["needle"] = riffdb.String(parameters.Needle)
@@ -1362,41 +1503,41 @@ if parameters.Offset != nil { input["offset"] = riffdb.U64(*parameters.Offset) }
 response, err := client.session.Invoke(ctx, AdminUsersStartsWithDescOperation, input, options); if err != nil { return QueryResult[AdminUsersStartsWithDescResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[AdminUsersStartsWithDescResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeAdminUsersStartsWithDescResult(response.Value); if err != nil { return QueryResult[AdminUsersStartsWithDescResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "AdminUsersStartsWithDesc", PlanHash: AdminUsersStartsWithDescQueryPlanHash}; return QueryResult[AdminUsersStartsWithDescResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) AdminUsersStartsWithDescAfterCommit(ctx context.Context, parameters AdminUsersStartsWithDescParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[AdminUsersStartsWithDescResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[AdminUsersStartsWithDescResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.AdminUsersStartsWithDesc(ctx, parameters, options) }
 
-const FindAccountByIdQueryPlanHash = "51ece0c8e7396f3f9efea7595a4224f856ae7984ff9bf15bcf9049427ad1f110"
+const FindAccountByIdQueryPlanHash = "14a08df3dd8a74ea0a5622804bf0c2424086ee73eb10ce57d7df336a7d25f5ba"
 var FindAccountByIdOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_account_by_id", InputSchemaHash: "a8efd0b9fe4e36f92ca57a7c5351df748b4c2adbd0e363e2a5ffb66ff4d23bdc"}
 func decodeFindAccountByIdResult(value riffdb.Value) (FindAccountByIdResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindAccountByIdFound{Outcome: outcome}
 raw, err = requiredField(fields, "accounts"); if err != nil { return nil, err }; result.Accounts, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "id"); if err != nil { return result, err }; result.Id, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "account_id"); if err != nil { return result, err }; result.AccountId, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "provider_id"); if err != nil { return result, err }; result.ProviderId, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "access_token"); if err != nil { return result, err }; result.AccessToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "refresh_token"); if err != nil { return result, err }; result.RefreshToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "access_token_expires_at"); if err != nil { return result, err }; result.AccessTokenExpiresAt, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (riffdb.Instant, error) { return riffdb.TimestampValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "refresh_token_expires_at"); if err != nil { return result, err }; result.RefreshTokenExpiresAt, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (riffdb.Instant, error) { return riffdb.TimestampValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "scope"); if err != nil { return result, err }; result.Scope, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "id_token"); if err != nil { return result, err }; result.IdToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "password"); if err != nil { return result, err }; result.Password, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindAccountById(ctx context.Context, parameters FindAccountByIdParams, optionsList ...QueryOptions) (QueryResult[FindAccountByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindAccountById(ctx context.Context, parameters FindAccountByIdParams, optionsList ...QueryOptions) (QueryResult[FindAccountByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["id"] = riffdb.UUID(parameters.Id)
 response, err := client.session.Invoke(ctx, FindAccountByIdOperation, input, options); if err != nil { return QueryResult[FindAccountByIdResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[FindAccountByIdResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeFindAccountByIdResult(response.Value); if err != nil { return QueryResult[FindAccountByIdResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "FindAccountById", PlanHash: FindAccountByIdQueryPlanHash}; return QueryResult[FindAccountByIdResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) FindAccountByIdAfterCommit(ctx context.Context, parameters FindAccountByIdParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindAccountByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindAccountById(ctx, parameters, options) }
 
-const FindAccountByProviderQueryPlanHash = "b104b38050396d747e59735cea4b562c305dccb7614a973f5177501825c91089"
+const FindAccountByProviderQueryPlanHash = "e6c4517a46d725780e79725ca3fdaba2208ef4b282d49f484121eee76c043831"
 var FindAccountByProviderOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_account_by_provider", InputSchemaHash: "7e48e77594d132efa4753eee93934c2ef61f6d82313edff8f7c84c7d8d4112f2"}
 func decodeFindAccountByProviderResult(value riffdb.Value) (FindAccountByProviderResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindAccountByProviderFound{Outcome: outcome}
 raw, err = requiredField(fields, "accounts"); if err != nil { return nil, err }; result.Accounts, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "id"); if err != nil { return result, err }; result.Id, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "account_id"); if err != nil { return result, err }; result.AccountId, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "provider_id"); if err != nil { return result, err }; result.ProviderId, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "access_token"); if err != nil { return result, err }; result.AccessToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "refresh_token"); if err != nil { return result, err }; result.RefreshToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "access_token_expires_at"); if err != nil { return result, err }; result.AccessTokenExpiresAt, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (riffdb.Instant, error) { return riffdb.TimestampValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "refresh_token_expires_at"); if err != nil { return result, err }; result.RefreshTokenExpiresAt, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (riffdb.Instant, error) { return riffdb.TimestampValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "scope"); if err != nil { return result, err }; result.Scope, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "id_token"); if err != nil { return result, err }; result.IdToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "password"); if err != nil { return result, err }; result.Password, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindAccountByProvider(ctx context.Context, parameters FindAccountByProviderParams, optionsList ...QueryOptions) (QueryResult[FindAccountByProviderResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountByProviderResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindAccountByProvider(ctx context.Context, parameters FindAccountByProviderParams, optionsList ...QueryOptions) (QueryResult[FindAccountByProviderResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountByProviderResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["account_id"] = riffdb.String(parameters.AccountId)
 input["provider_id"] = riffdb.String(parameters.ProviderId)
 response, err := client.session.Invoke(ctx, FindAccountByProviderOperation, input, options); if err != nil { return QueryResult[FindAccountByProviderResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[FindAccountByProviderResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeFindAccountByProviderResult(response.Value); if err != nil { return QueryResult[FindAccountByProviderResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "FindAccountByProvider", PlanHash: FindAccountByProviderQueryPlanHash}; return QueryResult[FindAccountByProviderResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) FindAccountByProviderAfterCommit(ctx context.Context, parameters FindAccountByProviderParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindAccountByProviderResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountByProviderResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindAccountByProvider(ctx, parameters, options) }
 
-const FindAccountsByUserIdQueryPlanHash = "0e517c2b2a10d95c12812d6374107379c80ce4638b962fad6f9092cc6b8b6c2e"
+const FindAccountsByUserIdQueryPlanHash = "ccdc524ca64ad667c209de25b4ce977f43b53ffdd8eb1b70fedf29fc99f27da6"
 var FindAccountsByUserIdOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_accounts_by_user_id", InputSchemaHash: "52291caa82b70870673211137e93f3ecda460cbe7b9fc465f0b9d7f30df05798"}
 func decodeFindAccountsByUserIdResult(value riffdb.Value) (FindAccountsByUserIdResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindAccountsByUserIdFound{Outcome: outcome}
 raw, err = requiredField(fields, "accounts"); if err != nil { return nil, err }; result.Accounts, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "id"); if err != nil { return result, err }; result.Id, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "account_id"); if err != nil { return result, err }; result.AccountId, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "provider_id"); if err != nil { return result, err }; result.ProviderId, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "access_token"); if err != nil { return result, err }; result.AccessToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "refresh_token"); if err != nil { return result, err }; result.RefreshToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "access_token_expires_at"); if err != nil { return result, err }; result.AccessTokenExpiresAt, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (riffdb.Instant, error) { return riffdb.TimestampValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "refresh_token_expires_at"); if err != nil { return result, err }; result.RefreshTokenExpiresAt, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (riffdb.Instant, error) { return riffdb.TimestampValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "scope"); if err != nil { return result, err }; result.Scope, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "id_token"); if err != nil { return result, err }; result.IdToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "password"); if err != nil { return result, err }; result.Password, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindAccountsByUserId(ctx context.Context, parameters FindAccountsByUserIdParams, optionsList ...QueryOptions) (QueryResult[FindAccountsByUserIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountsByUserIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindAccountsByUserId(ctx context.Context, parameters FindAccountsByUserIdParams, optionsList ...QueryOptions) (QueryResult[FindAccountsByUserIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountsByUserIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.After != nil { if options.Cursor != "" { return QueryResult[FindAccountsByUserIdResult]{}, errors.New("generated cursor conflicts with query options") }; options.Cursor = *parameters.After }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["user_id"] = riffdb.UUID(parameters.UserId)
@@ -1404,14 +1545,14 @@ response, err := client.session.Invoke(ctx, FindAccountsByUserIdOperation, input
 func (client *Client) FindAccountsByUserIdAfterCommit(ctx context.Context, parameters FindAccountsByUserIdParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindAccountsByUserIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountsByUserIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindAccountsByUserId(ctx, parameters, options) }
 func (client *Client) FindAccountsByUserIdPages(ctx context.Context, parameters FindAccountsByUserIdParams, maxPages uint32, optionsList ...QueryOptions) ([]QueryResult[FindAccountsByUserIdResult], error) { if maxPages == 0 { maxPages = 64 }; if maxPages > 1024 { return nil, errors.New("maxPages must be from 1 through 1024") }; var options QueryOptions; if len(optionsList) > 1 { return nil, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if parameters.After != nil { if options.Cursor != "" { return nil, errors.New("generated cursor conflicts with query options") }; options.Cursor = *parameters.After; parameters.After = nil }; pages := make([]QueryResult[FindAccountsByUserIdResult], 0, maxPages); for pageIndex := uint32(0); pageIndex < maxPages; pageIndex++ { page, err := client.FindAccountsByUserId(ctx, parameters, options); if err != nil { return nil, err }; pages = append(pages, page); if page.NextCursor == "" { break }; options.Cursor = page.NextCursor }; return pages, nil }
 
-const FindAccountsByUserProviderQueryPlanHash = "44124fb19b8f7fe35bb15824b87a0ed593c86b5821e81ad7fae1ab8636725183"
+const FindAccountsByUserProviderQueryPlanHash = "21d13b3c30b4a4059f3c436e290d11c20f0f1d1154e05fb48ae3dd0da882526d"
 var FindAccountsByUserProviderOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_accounts_by_user_provider", InputSchemaHash: "f389d8fa7caa4fcb96e1004158f88ce43ae9bccac48b8bf74087eab48c022df7"}
 func decodeFindAccountsByUserProviderResult(value riffdb.Value) (FindAccountsByUserProviderResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindAccountsByUserProviderFound{Outcome: outcome}
 raw, err = requiredField(fields, "accounts"); if err != nil { return nil, err }; result.Accounts, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { Id string; UserId string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; IdToken *string; Password *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "id"); if err != nil { return result, err }; result.Id, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "account_id"); if err != nil { return result, err }; result.AccountId, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "provider_id"); if err != nil { return result, err }; result.ProviderId, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "access_token"); if err != nil { return result, err }; result.AccessToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "refresh_token"); if err != nil { return result, err }; result.RefreshToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "access_token_expires_at"); if err != nil { return result, err }; result.AccessTokenExpiresAt, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (riffdb.Instant, error) { return riffdb.TimestampValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "refresh_token_expires_at"); if err != nil { return result, err }; result.RefreshTokenExpiresAt, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (riffdb.Instant, error) { return riffdb.TimestampValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "scope"); if err != nil { return result, err }; result.Scope, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "id_token"); if err != nil { return result, err }; result.IdToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "password"); if err != nil { return result, err }; result.Password, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindAccountsByUserProvider(ctx context.Context, parameters FindAccountsByUserProviderParams, optionsList ...QueryOptions) (QueryResult[FindAccountsByUserProviderResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountsByUserProviderResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindAccountsByUserProvider(ctx context.Context, parameters FindAccountsByUserProviderParams, optionsList ...QueryOptions) (QueryResult[FindAccountsByUserProviderResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountsByUserProviderResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.After != nil { if options.Cursor != "" { return QueryResult[FindAccountsByUserProviderResult]{}, errors.New("generated cursor conflicts with query options") }; options.Cursor = *parameters.After }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["user_id"] = riffdb.UUID(parameters.UserId)
@@ -1420,14 +1561,14 @@ response, err := client.session.Invoke(ctx, FindAccountsByUserProviderOperation,
 func (client *Client) FindAccountsByUserProviderAfterCommit(ctx context.Context, parameters FindAccountsByUserProviderParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindAccountsByUserProviderResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindAccountsByUserProviderResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindAccountsByUserProvider(ctx, parameters, options) }
 func (client *Client) FindAccountsByUserProviderPages(ctx context.Context, parameters FindAccountsByUserProviderParams, maxPages uint32, optionsList ...QueryOptions) ([]QueryResult[FindAccountsByUserProviderResult], error) { if maxPages == 0 { maxPages = 64 }; if maxPages > 1024 { return nil, errors.New("maxPages must be from 1 through 1024") }; var options QueryOptions; if len(optionsList) > 1 { return nil, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if parameters.After != nil { if options.Cursor != "" { return nil, errors.New("generated cursor conflicts with query options") }; options.Cursor = *parameters.After; parameters.After = nil }; pages := make([]QueryResult[FindAccountsByUserProviderResult], 0, maxPages); for pageIndex := uint32(0); pageIndex < maxPages; pageIndex++ { page, err := client.FindAccountsByUserProvider(ctx, parameters, options); if err != nil { return nil, err }; pages = append(pages, page); if page.NextCursor == "" { break }; options.Cursor = page.NextCursor }; return pages, nil }
 
-const FindActiveSessionsByUserIdQueryPlanHash = "218dbdff73dce68ba48b7f8a179791e6b46139ee84da3edbd96438045f60f8dc"
+const FindActiveSessionsByUserIdQueryPlanHash = "de1e5232a64a32057699b5ac21f1b43e69d755a3c143595f906fe63e16147264"
 var FindActiveSessionsByUserIdOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_active_sessions_by_user_id", InputSchemaHash: "56f77f3deba14d9fd74810cf14012109ddc4ba2f58c27a400a180df31ee38feb"}
 func decodeFindActiveSessionsByUserIdResult(value riffdb.Value) (FindActiveSessionsByUserIdResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindActiveSessionsByUserIdFound{Outcome: outcome}
 raw, err = requiredField(fields, "sessions"); if err != nil { return nil, err }; result.Sessions, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "id"); if err != nil { return result, err }; result.Id, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "token"); if err != nil { return result, err }; result.Token, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "expires_at"); if err != nil { return result, err }; result.ExpiresAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "ip_address"); if err != nil { return result, err }; result.IpAddress, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "user_agent"); if err != nil { return result, err }; result.UserAgent, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindActiveSessionsByUserId(ctx context.Context, parameters FindActiveSessionsByUserIdParams, optionsList ...QueryOptions) (QueryResult[FindActiveSessionsByUserIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindActiveSessionsByUserIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindActiveSessionsByUserId(ctx context.Context, parameters FindActiveSessionsByUserIdParams, optionsList ...QueryOptions) (QueryResult[FindActiveSessionsByUserIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindActiveSessionsByUserIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.After != nil { if options.Cursor != "" { return QueryResult[FindActiveSessionsByUserIdResult]{}, errors.New("generated cursor conflicts with query options") }; options.Cursor = *parameters.After }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["user_id"] = riffdb.UUID(parameters.UserId)
@@ -1436,14 +1577,29 @@ response, err := client.session.Invoke(ctx, FindActiveSessionsByUserIdOperation,
 func (client *Client) FindActiveSessionsByUserIdAfterCommit(ctx context.Context, parameters FindActiveSessionsByUserIdParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindActiveSessionsByUserIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindActiveSessionsByUserIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindActiveSessionsByUserId(ctx, parameters, options) }
 func (client *Client) FindActiveSessionsByUserIdPages(ctx context.Context, parameters FindActiveSessionsByUserIdParams, maxPages uint32, optionsList ...QueryOptions) ([]QueryResult[FindActiveSessionsByUserIdResult], error) { if maxPages == 0 { maxPages = 64 }; if maxPages > 1024 { return nil, errors.New("maxPages must be from 1 through 1024") }; var options QueryOptions; if len(optionsList) > 1 { return nil, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if parameters.After != nil { if options.Cursor != "" { return nil, errors.New("generated cursor conflicts with query options") }; options.Cursor = *parameters.After; parameters.After = nil }; pages := make([]QueryResult[FindActiveSessionsByUserIdResult], 0, maxPages); for pageIndex := uint32(0); pageIndex < maxPages; pageIndex++ { page, err := client.FindActiveSessionsByUserId(ctx, parameters, options); if err != nil { return nil, err }; pages = append(pages, page); if page.NextCursor == "" { break }; options.Cursor = page.NextCursor }; return pages, nil }
 
-const FindExpiredVerificationIdsQueryPlanHash = "e24fe82a3a724a9d45044dc668d450e61b1177f5866423c07bd33100d49428c1"
+const FindCredentialAccountQueryPlanHash = "f968271d103a76cc6b2a5496f5cceffe4cff5aa39d2a370379b518d8e7d90771"
+var FindCredentialAccountOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_credential_account", InputSchemaHash: "108a21aa464170aff1274c8f9af12f9c84d899483e63eb62f4fc9bed6e4fc040"}
+func decodeFindCredentialAccountResult(value riffdb.Value) (FindCredentialAccountResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
+case "Found": result := FindCredentialAccountFound{Outcome: outcome}
+raw, err = requiredField(fields, "accounts"); if err != nil { return nil, err }; result.Accounts, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { OrganizationId string; UserId string; Id string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; IdToken *string; Password *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { OrganizationId string; UserId string; Id string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; IdToken *string; Password *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { OrganizationId string; UserId string; Id string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; IdToken *string; Password *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { OrganizationId string; UserId string; Id string; AccountId string; ProviderId string; AccessToken *string; RefreshToken *string; IdToken *string; Password *string; AccessTokenExpiresAt *riffdb.Instant; RefreshTokenExpiresAt *riffdb.Instant; Scope *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "organization_id"); if err != nil { return result, err }; result.OrganizationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "id"); if err != nil { return result, err }; result.Id, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "account_id"); if err != nil { return result, err }; result.AccountId, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "provider_id"); if err != nil { return result, err }; result.ProviderId, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "access_token"); if err != nil { return result, err }; result.AccessToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "refresh_token"); if err != nil { return result, err }; result.RefreshToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "id_token"); if err != nil { return result, err }; result.IdToken, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "password"); if err != nil { return result, err }; result.Password, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "access_token_expires_at"); if err != nil { return result, err }; result.AccessTokenExpiresAt, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (riffdb.Instant, error) { return riffdb.TimestampValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "refresh_token_expires_at"); if err != nil { return result, err }; result.RefreshTokenExpiresAt, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (riffdb.Instant, error) { return riffdb.TimestampValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "scope"); if err != nil { return result, err }; result.Scope, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
+return result, nil
+default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
+func (client *Client) FindCredentialAccount(ctx context.Context, parameters FindCredentialAccountParams, optionsList ...QueryOptions) (QueryResult[FindCredentialAccountResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindCredentialAccountResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
+input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
+input["user_id"] = riffdb.UUID(parameters.UserId)
+input["account_id"] = riffdb.String(parameters.AccountId)
+input["provider_id"] = riffdb.String(parameters.ProviderId)
+response, err := client.session.Invoke(ctx, FindCredentialAccountOperation, input, options); if err != nil { return QueryResult[FindCredentialAccountResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[FindCredentialAccountResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeFindCredentialAccountResult(response.Value); if err != nil { return QueryResult[FindCredentialAccountResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "FindCredentialAccount", PlanHash: FindCredentialAccountQueryPlanHash}; return QueryResult[FindCredentialAccountResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
+func (client *Client) FindCredentialAccountAfterCommit(ctx context.Context, parameters FindCredentialAccountParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindCredentialAccountResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindCredentialAccountResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindCredentialAccount(ctx, parameters, options) }
+
+const FindExpiredVerificationIdsQueryPlanHash = "6c799850ba3b2eb3222aac85a76f40492c46de76870075b029f3b4ac897ed8b9"
 var FindExpiredVerificationIdsOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_expired_verification_ids", InputSchemaHash: "b2397d3409885ae750a1d8b4d53bc6905e59348dfc79f0b4d2934981ad4cb1b2"}
 func decodeFindExpiredVerificationIdsResult(value riffdb.Value) (FindExpiredVerificationIdsResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindExpiredVerificationIdsFound{Outcome: outcome}
 raw, err = requiredField(fields, "verifications"); if err != nil { return nil, err }; result.Verifications, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { VerificationId string }, error) { return func() (struct { VerificationId string }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { VerificationId string }{}, err }; var result struct { VerificationId string }; var raw riffdb.Value; raw, err = requiredField(fields, "verification_id"); if err != nil { return result, err }; result.VerificationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindExpiredVerificationIds(ctx context.Context, parameters FindExpiredVerificationIdsParams, optionsList ...QueryOptions) (QueryResult[FindExpiredVerificationIdsResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindExpiredVerificationIdsResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindExpiredVerificationIds(ctx context.Context, parameters FindExpiredVerificationIdsParams, optionsList ...QueryOptions) (QueryResult[FindExpiredVerificationIdsResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindExpiredVerificationIdsResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.After != nil { if options.Cursor != "" { return QueryResult[FindExpiredVerificationIdsResult]{}, errors.New("generated cursor conflicts with query options") }; options.Cursor = *parameters.After }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["expires_before"] = riffdb.TimestampFrom(parameters.ExpiresBefore)
@@ -1451,66 +1607,68 @@ response, err := client.session.Invoke(ctx, FindExpiredVerificationIdsOperation,
 func (client *Client) FindExpiredVerificationIdsAfterCommit(ctx context.Context, parameters FindExpiredVerificationIdsParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindExpiredVerificationIdsResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindExpiredVerificationIdsResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindExpiredVerificationIds(ctx, parameters, options) }
 func (client *Client) FindExpiredVerificationIdsPages(ctx context.Context, parameters FindExpiredVerificationIdsParams, maxPages uint32, optionsList ...QueryOptions) ([]QueryResult[FindExpiredVerificationIdsResult], error) { if maxPages == 0 { maxPages = 64 }; if maxPages > 1024 { return nil, errors.New("maxPages must be from 1 through 1024") }; var options QueryOptions; if len(optionsList) > 1 { return nil, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if parameters.After != nil { if options.Cursor != "" { return nil, errors.New("generated cursor conflicts with query options") }; options.Cursor = *parameters.After; parameters.After = nil }; pages := make([]QueryResult[FindExpiredVerificationIdsResult], 0, maxPages); for pageIndex := uint32(0); pageIndex < maxPages; pageIndex++ { page, err := client.FindExpiredVerificationIds(ctx, parameters, options); if err != nil { return nil, err }; pages = append(pages, page); if page.NextCursor == "" { break }; options.Cursor = page.NextCursor }; return pages, nil }
 
-const FindLatestVerificationQueryPlanHash = "54336205fa315da75d390d062055723e36d07ef6596e19f756d319a8bc875023"
+const FindLatestVerificationQueryPlanHash = "b3832c0a8a316d3fcbc62b388fbe09ceb6624b55482195f7642553467cba6fcb"
 var FindLatestVerificationOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_latest_verification", InputSchemaHash: "414c00deb31dd873e434c8006a8caa9d2b360457abe0f8269440d6c761dfdc94"}
 func decodeFindLatestVerificationResult(value riffdb.Value) (FindLatestVerificationResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindLatestVerificationFound{Outcome: outcome}
 raw, err = requiredField(fields, "verifications"); if err != nil { return nil, err }; result.Verifications, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { VerificationId string; Identifier string; Value string; ExpiresAt riffdb.Instant; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { VerificationId string; Identifier string; Value string; ExpiresAt riffdb.Instant; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { VerificationId string; Identifier string; Value string; ExpiresAt riffdb.Instant; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { VerificationId string; Identifier string; Value string; ExpiresAt riffdb.Instant; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "verification_id"); if err != nil { return result, err }; result.VerificationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "identifier"); if err != nil { return result, err }; result.Identifier, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "value"); if err != nil { return result, err }; result.Value, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "expires_at"); if err != nil { return result, err }; result.ExpiresAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindLatestVerification(ctx context.Context, parameters FindLatestVerificationParams, optionsList ...QueryOptions) (QueryResult[FindLatestVerificationResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindLatestVerificationResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindLatestVerification(ctx context.Context, parameters FindLatestVerificationParams, optionsList ...QueryOptions) (QueryResult[FindLatestVerificationResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindLatestVerificationResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["identifier"] = riffdb.String(parameters.Identifier)
 response, err := client.session.Invoke(ctx, FindLatestVerificationOperation, input, options); if err != nil { return QueryResult[FindLatestVerificationResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[FindLatestVerificationResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeFindLatestVerificationResult(response.Value); if err != nil { return QueryResult[FindLatestVerificationResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "FindLatestVerification", PlanHash: FindLatestVerificationQueryPlanHash}; return QueryResult[FindLatestVerificationResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) FindLatestVerificationAfterCommit(ctx context.Context, parameters FindLatestVerificationParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindLatestVerificationResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindLatestVerificationResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindLatestVerification(ctx, parameters, options) }
 
-const FindSessionByIdQueryPlanHash = "653cfab6a75b5e2624620b0b5504b19d36f778c8775606fa0f3bb0c1d51e6bc0"
+const FindSessionByIdQueryPlanHash = "c92eb2035c0e3ca7dedbaa42a4e2efe7bc4786a65213394da7f5d3beb579a2a1"
 var FindSessionByIdOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_session_by_id", InputSchemaHash: "a8efd0b9fe4e36f92ca57a7c5351df748b4c2adbd0e363e2a5ffb66ff4d23bdc"}
 func decodeFindSessionByIdResult(value riffdb.Value) (FindSessionByIdResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindSessionByIdFound{Outcome: outcome}
 raw, err = requiredField(fields, "sessions"); if err != nil { return nil, err }; result.Sessions, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "id"); if err != nil { return result, err }; result.Id, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "token"); if err != nil { return result, err }; result.Token, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "expires_at"); if err != nil { return result, err }; result.ExpiresAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "ip_address"); if err != nil { return result, err }; result.IpAddress, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "user_agent"); if err != nil { return result, err }; result.UserAgent, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindSessionById(ctx context.Context, parameters FindSessionByIdParams, optionsList ...QueryOptions) (QueryResult[FindSessionByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindSessionById(ctx context.Context, parameters FindSessionByIdParams, optionsList ...QueryOptions) (QueryResult[FindSessionByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["id"] = riffdb.UUID(parameters.Id)
 response, err := client.session.Invoke(ctx, FindSessionByIdOperation, input, options); if err != nil { return QueryResult[FindSessionByIdResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[FindSessionByIdResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeFindSessionByIdResult(response.Value); if err != nil { return QueryResult[FindSessionByIdResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "FindSessionById", PlanHash: FindSessionByIdQueryPlanHash}; return QueryResult[FindSessionByIdResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) FindSessionByIdAfterCommit(ctx context.Context, parameters FindSessionByIdParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindSessionByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindSessionById(ctx, parameters, options) }
 
-const FindSessionByTokenQueryPlanHash = "b5e701701b0ac99b4328200089b2507f31c0be55df78a275d83f7be99f8b7061"
+const FindSessionByTokenQueryPlanHash = "a8a12334a3d34c30d54be828bdcc9b9b77223303c3f9681e4a602c92341876ec"
 var FindSessionByTokenOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_session_by_token", InputSchemaHash: "0ff142e840e9d2d322c37be4688526fc1348f508cc4976856bd7e4d2570859e8"}
 func decodeFindSessionByTokenResult(value riffdb.Value) (FindSessionByTokenResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindSessionByTokenFound{Outcome: outcome}
 raw, err = requiredField(fields, "sessions"); if err != nil { return nil, err }; result.Sessions, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "id"); if err != nil { return result, err }; result.Id, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "token"); if err != nil { return result, err }; result.Token, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "expires_at"); if err != nil { return result, err }; result.ExpiresAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "ip_address"); if err != nil { return result, err }; result.IpAddress, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "user_agent"); if err != nil { return result, err }; result.UserAgent, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindSessionByToken(ctx context.Context, parameters FindSessionByTokenParams, optionsList ...QueryOptions) (QueryResult[FindSessionByTokenResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionByTokenResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindSessionByToken(ctx context.Context, parameters FindSessionByTokenParams, optionsList ...QueryOptions) (QueryResult[FindSessionByTokenResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionByTokenResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["token"] = riffdb.String(parameters.Token)
 response, err := client.session.Invoke(ctx, FindSessionByTokenOperation, input, options); if err != nil { return QueryResult[FindSessionByTokenResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[FindSessionByTokenResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeFindSessionByTokenResult(response.Value); if err != nil { return QueryResult[FindSessionByTokenResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "FindSessionByToken", PlanHash: FindSessionByTokenQueryPlanHash}; return QueryResult[FindSessionByTokenResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) FindSessionByTokenAfterCommit(ctx context.Context, parameters FindSessionByTokenParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindSessionByTokenResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionByTokenResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindSessionByToken(ctx, parameters, options) }
 
-const FindSessionsByTokenSetQueryPlanHash = "56c683d1815bf0c3e14c0585f314de378b43f9f4e401312c645efc70bd42969b"
+const FindSessionsByTokenSetQueryPlanHash = "7e23187b537599c4c2361d34ea866b5b719f63feda0135587b5ec6afd5ce62f6"
+const FindSessionsByTokenSetTokensMaxItems = 32
 var FindSessionsByTokenSetOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_sessions_by_token_set", InputSchemaHash: "6e07645237cd913d73a45bd7f863e3ca8d9ae09fdfecdb7494246fa80dea3899"}
 func decodeFindSessionsByTokenSetResult(value riffdb.Value) (FindSessionsByTokenSetResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindSessionsByTokenSetFound{Outcome: outcome}
 raw, err = requiredField(fields, "sessions"); if err != nil { return nil, err }; result.Sessions, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "id"); if err != nil { return result, err }; result.Id, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "token"); if err != nil { return result, err }; result.Token, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "expires_at"); if err != nil { return result, err }; result.ExpiresAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "ip_address"); if err != nil { return result, err }; result.IpAddress, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "user_agent"); if err != nil { return result, err }; result.UserAgent, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindSessionsByTokenSet(ctx context.Context, parameters FindSessionsByTokenSetParams, optionsList ...QueryOptions) (QueryResult[FindSessionsByTokenSetResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionsByTokenSetResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindSessionsByTokenSet(ctx context.Context, parameters FindSessionsByTokenSetParams, optionsList ...QueryOptions) (QueryResult[FindSessionsByTokenSetResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionsByTokenSetResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["tokens"] = riffdb.Values(parameters.Tokens, func(item string) riffdb.Value { return riffdb.String(item) })
 response, err := client.session.Invoke(ctx, FindSessionsByTokenSetOperation, input, options); if err != nil { return QueryResult[FindSessionsByTokenSetResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[FindSessionsByTokenSetResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeFindSessionsByTokenSetResult(response.Value); if err != nil { return QueryResult[FindSessionsByTokenSetResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "FindSessionsByTokenSet", PlanHash: FindSessionsByTokenSetQueryPlanHash}; return QueryResult[FindSessionsByTokenSetResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) FindSessionsByTokenSetAfterCommit(ctx context.Context, parameters FindSessionsByTokenSetParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindSessionsByTokenSetResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionsByTokenSetResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindSessionsByTokenSet(ctx, parameters, options) }
+func (client *Client) FindSessionsByTokenSetAll(ctx context.Context, parameters FindSessionsByTokenSetParams, maxPages uint32, optionsList ...QueryOptions) (QueryResult[FindSessionsByTokenSetFound], error) { if maxPages == 0 { maxPages = 64 }; if maxPages > 1024 { return QueryResult[FindSessionsByTokenSetFound]{}, errors.New("maxPages must be from 1 through 1024") }; var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionsByTokenSetFound]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.Cursor != "" { return QueryResult[FindSessionsByTokenSetFound]{}, errors.New("FindSessionsByTokenSetAll does not accept an initial cursor") }; rawItems := parameters.Tokens; if len(rawItems) == 0 { return QueryResult[FindSessionsByTokenSetFound]{}, errors.New("tokens must contain at least 1 item") }; seen := make(map[string]struct{}, len(rawItems)); items := make([]string, 0, len(rawItems)); for _, item := range rawItems { if _, ok := seen[item]; !ok { seen[item] = struct{}{}; items = append(items, item) } }; var pinnedHead *uint64; if options.ReadAfterCommit != nil { commitSeq := *options.ReadAfterCommit; pinnedHead = &commitSeq } else { pinnedHead = client.LastCommitSequence() }; var highestHead uint64; var latestIdentity QueryIdentity; merged := FindSessionsByTokenSetFound{Outcome: "Found"}; pagesRemaining := maxPages; for offset := 0; offset < len(items); offset += FindSessionsByTokenSetTokensMaxItems { end := offset + FindSessionsByTokenSetTokensMaxItems; if end > len(items) { end = len(items) }; chunkParams := parameters; chunkParams.Tokens = items[offset:end]; chunkOptions := options; chunkOptions.Cursor = ""; for { if pagesRemaining == 0 { return QueryResult[FindSessionsByTokenSetFound]{}, errors.New("FindSessionsByTokenSetAll exceeded maxPages (1..=1024)") }; pagesRemaining--; chunkOptions.ReadAfterCommit = pinnedHead; page, err := client.FindSessionsByTokenSet(ctx, chunkParams, chunkOptions); if err != nil { return QueryResult[FindSessionsByTokenSetFound]{}, err }; found, err := UnwrapFindSessionsByTokenSetFound(page.Value); if err != nil { return QueryResult[FindSessionsByTokenSetFound]{}, err }; if merged.Sessions == nil { merged.Sessions = append(found.Sessions[:0:0], found.Sessions...) } else { merged.Sessions = append(merged.Sessions, found.Sessions...) }; latestIdentity = page.Identity; if page.ApplicationHead > highestHead { highestHead = page.ApplicationHead }; if pinnedHead == nil || page.ApplicationHead > *pinnedHead { headCopy := page.ApplicationHead; pinnedHead = &headCopy }; if page.NextCursor == "" { break }; chunkOptions.Cursor = page.NextCursor } }; return QueryResult[FindSessionsByTokenSetFound]{Value: merged, Identity: latestIdentity, ApplicationHead: highestHead}, nil }
 
-const FindSessionsByUserIdQueryPlanHash = "84de4cd840d30dc9cd575e1f1daea8de94f0efa63187b646e273ba633a5d693f"
+const FindSessionsByUserIdQueryPlanHash = "a3277546d8b0c0059b850c368ae4925000c255e69b7ff005f4b3d2ef61b504af"
 var FindSessionsByUserIdOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_sessions_by_user_id", InputSchemaHash: "52291caa82b70870673211137e93f3ecda460cbe7b9fc465f0b9d7f30df05798"}
 func decodeFindSessionsByUserIdResult(value riffdb.Value) (FindSessionsByUserIdResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindSessionsByUserIdFound{Outcome: outcome}
 raw, err = requiredField(fields, "sessions"); if err != nil { return nil, err }; result.Sessions, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { Id string; UserId string; Token string; ExpiresAt riffdb.Instant; IpAddress *string; UserAgent *string; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "id"); if err != nil { return result, err }; result.Id, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "user_id"); if err != nil { return result, err }; result.UserId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "token"); if err != nil { return result, err }; result.Token, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "expires_at"); if err != nil { return result, err }; result.ExpiresAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "ip_address"); if err != nil { return result, err }; result.IpAddress, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "user_agent"); if err != nil { return result, err }; result.UserAgent, err = riffdb.DecodeOptional(raw, func(item riffdb.Value) (string, error) { return riffdb.StringValue(item) }); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindSessionsByUserId(ctx context.Context, parameters FindSessionsByUserIdParams, optionsList ...QueryOptions) (QueryResult[FindSessionsByUserIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionsByUserIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindSessionsByUserId(ctx context.Context, parameters FindSessionsByUserIdParams, optionsList ...QueryOptions) (QueryResult[FindSessionsByUserIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionsByUserIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.After != nil { if options.Cursor != "" { return QueryResult[FindSessionsByUserIdResult]{}, errors.New("generated cursor conflicts with query options") }; options.Cursor = *parameters.After }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["user_id"] = riffdb.UUID(parameters.UserId)
@@ -1518,7 +1676,7 @@ response, err := client.session.Invoke(ctx, FindSessionsByUserIdOperation, input
 func (client *Client) FindSessionsByUserIdAfterCommit(ctx context.Context, parameters FindSessionsByUserIdParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindSessionsByUserIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindSessionsByUserIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindSessionsByUserId(ctx, parameters, options) }
 func (client *Client) FindSessionsByUserIdPages(ctx context.Context, parameters FindSessionsByUserIdParams, maxPages uint32, optionsList ...QueryOptions) ([]QueryResult[FindSessionsByUserIdResult], error) { if maxPages == 0 { maxPages = 64 }; if maxPages > 1024 { return nil, errors.New("maxPages must be from 1 through 1024") }; var options QueryOptions; if len(optionsList) > 1 { return nil, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if parameters.After != nil { if options.Cursor != "" { return nil, errors.New("generated cursor conflicts with query options") }; options.Cursor = *parameters.After; parameters.After = nil }; pages := make([]QueryResult[FindSessionsByUserIdResult], 0, maxPages); for pageIndex := uint32(0); pageIndex < maxPages; pageIndex++ { page, err := client.FindSessionsByUserId(ctx, parameters, options); if err != nil { return nil, err }; pages = append(pages, page); if page.NextCursor == "" { break }; options.Cursor = page.NextCursor }; return pages, nil }
 
-const FindUserByEmailQueryPlanHash = "ef647a48d55b825dbe566c29b03dd3fb97444df49f991bd0441d60cbb4115078"
+const FindUserByEmailQueryPlanHash = "b167b8cb2fb5ce19685491b47da4e816665b840e0f0e463666f6302134472b9a"
 var FindUserByEmailOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_user_by_email", InputSchemaHash: "7d3b1da87ea1ee59893e110cd8f8a5eacb522a8fde24a7e8aa9b7c13340990b9"}
 func decodeFindUserByEmailResult(value riffdb.Value) (FindUserByEmailResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindUserByEmailFound{Outcome: outcome}
@@ -1535,13 +1693,13 @@ row.Revision, err = riffdb.U64Value(rawRow[5]); if err != nil { return nil, err
 row.UpdatedAt, err = riffdb.TimestampValue(rawRow[6]); if err != nil { return nil, err }
 row.UserId, err = riffdb.UUIDValue(rawRow[7]); if err != nil { return nil, err }
 rows = append(rows, row) }; return FindUserByEmailFound{Outcome: "Found", Users: rows}, nil }
-func (client *Client) FindUserByEmail(ctx context.Context, parameters FindUserByEmailParams, optionsList ...QueryOptions) (QueryResult[FindUserByEmailResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindUserByEmailResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindUserByEmail(ctx context.Context, parameters FindUserByEmailParams, optionsList ...QueryOptions) (QueryResult[FindUserByEmailResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindUserByEmailResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["email"] = riffdb.String(parameters.Email)
 options.AcceptCompactResult = true; response, err := client.session.Invoke(ctx, FindUserByEmailOperation, input, options); if err != nil { return QueryResult[FindUserByEmailResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[FindUserByEmailResult]{}, errors.New("RiffDB driver omitted query frontier") }; var value FindUserByEmailResult; if response.Compact != nil { value, err = decodeFindUserByEmailCompact(response.Compact) } else { value, err = decodeFindUserByEmailResult(response.Value) }; if err != nil { return QueryResult[FindUserByEmailResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "FindUserByEmail", PlanHash: FindUserByEmailQueryPlanHash}; return QueryResult[FindUserByEmailResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) FindUserByEmailAfterCommit(ctx context.Context, parameters FindUserByEmailParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindUserByEmailResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindUserByEmailResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindUserByEmail(ctx, parameters, options) }
 
-const FindUserByIdQueryPlanHash = "45fe0e1bda91ecd52e3a5c64c656c168c1200b1869b0f68665fd9e578439b9fd"
+const FindUserByIdQueryPlanHash = "25d4a0a77d5df64ab6187528f9fac6b205a03c33e01c9ea6b573e8316b78b924"
 var FindUserByIdOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_user_by_id", InputSchemaHash: "a8efd0b9fe4e36f92ca57a7c5351df748b4c2adbd0e363e2a5ffb66ff4d23bdc"}
 func decodeFindUserByIdResult(value riffdb.Value) (FindUserByIdResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindUserByIdFound{Outcome: outcome}
@@ -1550,13 +1708,13 @@ return result, nil
 case "Missing": result := FindUserByIdMissing{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindUserById(ctx context.Context, parameters FindUserByIdParams, optionsList ...QueryOptions) (QueryResult[FindUserByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindUserByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindUserById(ctx context.Context, parameters FindUserByIdParams, optionsList ...QueryOptions) (QueryResult[FindUserByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindUserByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["id"] = riffdb.UUID(parameters.Id)
 response, err := client.session.Invoke(ctx, FindUserByIdOperation, input, options); if err != nil { return QueryResult[FindUserByIdResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[FindUserByIdResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeFindUserByIdResult(response.Value); if err != nil { return QueryResult[FindUserByIdResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "FindUserById", PlanHash: FindUserByIdQueryPlanHash}; return QueryResult[FindUserByIdResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) FindUserByIdAfterCommit(ctx context.Context, parameters FindUserByIdParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindUserByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindUserByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindUserById(ctx, parameters, options) }
 
-const FindVerificationByIdQueryPlanHash = "3755eceb567801c6795c13a9e8868955cfe1bf185d204196f4c614d29f78c6aa"
+const FindVerificationByIdQueryPlanHash = "54f07c7eba7d51857dd6473e39304dc798bf7084ca946dfa7f0203633a5133ac"
 var FindVerificationByIdOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_verification_by_id", InputSchemaHash: "a8efd0b9fe4e36f92ca57a7c5351df748b4c2adbd0e363e2a5ffb66ff4d23bdc"}
 func decodeFindVerificationByIdResult(value riffdb.Value) (FindVerificationByIdResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindVerificationByIdFound{Outcome: outcome}
@@ -1565,20 +1723,20 @@ return result, nil
 case "Missing": result := FindVerificationByIdMissing{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindVerificationById(ctx context.Context, parameters FindVerificationByIdParams, optionsList ...QueryOptions) (QueryResult[FindVerificationByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindVerificationByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindVerificationById(ctx context.Context, parameters FindVerificationByIdParams, optionsList ...QueryOptions) (QueryResult[FindVerificationByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindVerificationByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["id"] = riffdb.UUID(parameters.Id)
 response, err := client.session.Invoke(ctx, FindVerificationByIdOperation, input, options); if err != nil { return QueryResult[FindVerificationByIdResult]{}, err }; if response.ApplicationHead == nil { return QueryResult[FindVerificationByIdResult]{}, errors.New("RiffDB driver omitted query frontier") }; value, err := decodeFindVerificationByIdResult(response.Value); if err != nil { return QueryResult[FindVerificationByIdResult]{}, err }; identity := QueryIdentity{ContractLineage: ContractLineage, ContractVersion: ContractVersion, ContractBundleHash: ContractBundleHash, ModuleHash: QueryModuleHash, QueryName: "FindVerificationById", PlanHash: FindVerificationByIdQueryPlanHash}; return QueryResult[FindVerificationByIdResult]{Value: value, Identity: identity, ApplicationHead: *response.ApplicationHead, NextCursor: response.Cursor}, nil }
 func (client *Client) FindVerificationByIdAfterCommit(ctx context.Context, parameters FindVerificationByIdParams, commitSequence uint64, optionsList ...QueryOptions) (QueryResult[FindVerificationByIdResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindVerificationByIdResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; options.ReadAfterCommit = &commitSequence; return client.FindVerificationById(ctx, parameters, options) }
 
-const FindVerificationsByIdentifierQueryPlanHash = "d98f43e146032b3cd1d0dfb2eacd432795f1545fcfa00e0e45b0fbd891d8b3ed"
+const FindVerificationsByIdentifierQueryPlanHash = "4c768ae1d966454e9b791cd57a6311476947b5c457020943a50bc3cfee90765b"
 var FindVerificationsByIdentifierOperation = riffdb.Operation{Name: "riffdb_better_auth_core_find_verifications_by_identifier", InputSchemaHash: "f61c6a3fd1f9b7496a437e77f166f72e9c36d27d832811ac96f146fa2999cc37"}
 func decodeFindVerificationsByIdentifierResult(value riffdb.Value) (FindVerificationsByIdentifierResult, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; var raw riffdb.Value; switch outcome {
 case "Found": result := FindVerificationsByIdentifierFound{Outcome: outcome}
 raw, err = requiredField(fields, "verifications"); if err != nil { return nil, err }; result.Verifications, err = riffdb.DecodeValues(raw, func(item riffdb.Value) (struct { VerificationId string; Identifier string; Value string; ExpiresAt riffdb.Instant; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { return func() (struct { VerificationId string; Identifier string; Value string; ExpiresAt riffdb.Instant; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }, error) { fields, err := riffdb.RecordFields(item); if err != nil { return struct { VerificationId string; Identifier string; Value string; ExpiresAt riffdb.Instant; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }{}, err }; var result struct { VerificationId string; Identifier string; Value string; ExpiresAt riffdb.Instant; CreatedAt riffdb.Instant; UpdatedAt riffdb.Instant; Revision uint64 }; var raw riffdb.Value; raw, err = requiredField(fields, "verification_id"); if err != nil { return result, err }; result.VerificationId, err = riffdb.UUIDValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "identifier"); if err != nil { return result, err }; result.Identifier, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "value"); if err != nil { return result, err }; result.Value, err = riffdb.StringValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "expires_at"); if err != nil { return result, err }; result.ExpiresAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "created_at"); if err != nil { return result, err }; result.CreatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "updated_at"); if err != nil { return result, err }; result.UpdatedAt, err = riffdb.TimestampValue(raw); if err != nil { return result, err }; raw, err = requiredField(fields, "revision"); if err != nil { return result, err }; result.Revision, err = riffdb.U64Value(raw); if err != nil { return result, err }; return result, nil }() }); if err != nil { return nil, err }
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown query outcome") } }
-func (client *Client) FindVerificationsByIdentifier(ctx context.Context, parameters FindVerificationsByIdentifierParams, optionsList ...QueryOptions) (QueryResult[FindVerificationsByIdentifierResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindVerificationsByIdentifierResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil && client.readAfterCommit != nil { commitSeq := *client.readAfterCommit; options.ReadAfterCommit = &commitSeq }; input := map[string]riffdb.Value{}
+func (client *Client) FindVerificationsByIdentifier(ctx context.Context, parameters FindVerificationsByIdentifierParams, optionsList ...QueryOptions) (QueryResult[FindVerificationsByIdentifierResult], error) { var options QueryOptions; if len(optionsList) > 1 { return QueryResult[FindVerificationsByIdentifierResult]{}, errors.New("invalid generated RiffDB query options") } else if len(optionsList) == 1 { options = optionsList[0] }; if options.ReadAfterCommit == nil { options.ReadAfterCommit = client.LastCommitSequence() }; input := map[string]riffdb.Value{}
 if parameters.After != nil { if options.Cursor != "" { return QueryResult[FindVerificationsByIdentifierResult]{}, errors.New("generated cursor conflicts with query options") }; options.Cursor = *parameters.After }
 input["organization_id"] = riffdb.UUID(parameters.OrganizationId)
 input["identifier"] = riffdb.String(parameters.Identifier)
@@ -1606,8 +1764,9 @@ return result, nil
 case "VerificationConsumeMissing": result := ConsumeVerificationVerificationConsumeMissing{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) ConsumeVerification(ctx context.Context, input ConsumeVerificationInput) (CommandResult[ConsumeVerificationOutcome], error) { response, err := client.session.Invoke(ctx, ConsumeVerificationOperation, encodeConsumeVerificationInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[ConsumeVerificationOutcome]{}, err }; outcome, err := decodeConsumeVerificationOutcome(response.Value); if err != nil { return CommandResult[ConsumeVerificationOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[ConsumeVerificationOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: ConsumeVerificationPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) ConsumeVerificationBatch(ctx context.Context, inputs []ConsumeVerificationInput, concurrency, checkpoint uint32) (BatchResult[ConsumeVerificationOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeConsumeVerificationInput(input) }; response, err := client.session.Batch(ctx, ConsumeVerificationOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[ConsumeVerificationOutcome]{}, err }; result := BatchResult[ConsumeVerificationOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[ConsumeVerificationOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[ConsumeVerificationOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeConsumeVerificationOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[ConsumeVerificationOutcome]{}, decodeErr }; converted.Result = &CommandResult[ConsumeVerificationOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: ConsumeVerificationPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) ConsumeVerification(ctx context.Context, input ConsumeVerificationInput) (CommandResult[ConsumeVerificationOutcome], error) { response, err := client.session.Invoke(ctx, ConsumeVerificationOperation, encodeConsumeVerificationInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[ConsumeVerificationOutcome]{}, err }; outcome, err := decodeConsumeVerificationOutcome(response.Value); if err != nil { return CommandResult[ConsumeVerificationOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[ConsumeVerificationOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: ConsumeVerificationPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) ConsumeVerificationBatch(ctx context.Context, inputs []ConsumeVerificationInput, concurrency, checkpoint uint32) (BatchResult[ConsumeVerificationOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeConsumeVerificationInput(input) }; response, err := client.session.Batch(ctx, ConsumeVerificationOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[ConsumeVerificationOutcome]{}, err }; result := BatchResult[ConsumeVerificationOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[ConsumeVerificationOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[ConsumeVerificationOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeConsumeVerificationOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[ConsumeVerificationOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[ConsumeVerificationOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: ConsumeVerificationPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const ConsumeVerificationSetPlanHash = "cc5e0d69851c61f11bbbca45ad00bec80b32687a94272379e133fbf854d59780"
 var ConsumeVerificationSetOperation = riffdb.Operation{Name: "riffdb_better_auth_core_consume_verification_set", InputSchemaHash: "ce88d8052f760625503f8a732f9813446ef7cc042d726ee1826c05c437c0929c"}
@@ -1623,8 +1782,29 @@ return result, nil
 case "VerificationConsumeMissing": result := ConsumeVerificationSetVerificationConsumeMissing{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) ConsumeVerificationSet(ctx context.Context, input ConsumeVerificationSetInput) (CommandResult[ConsumeVerificationSetOutcome], error) { if err := validateConsumeVerificationSetInput(input); err != nil { return CommandResult[ConsumeVerificationSetOutcome]{}, err }; response, err := client.session.Invoke(ctx, ConsumeVerificationSetOperation, encodeConsumeVerificationSetInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[ConsumeVerificationSetOutcome]{}, err }; outcome, err := decodeConsumeVerificationSetOutcome(response.Value); if err != nil { return CommandResult[ConsumeVerificationSetOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[ConsumeVerificationSetOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: ConsumeVerificationSetPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) ConsumeVerificationSetBatch(ctx context.Context, inputs []ConsumeVerificationSetInput, concurrency, checkpoint uint32) (BatchResult[ConsumeVerificationSetOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateConsumeVerificationSetInput(input); err != nil { return BatchResult[ConsumeVerificationSetOutcome]{}, err }; encoded[index] = encodeConsumeVerificationSetInput(input) }; response, err := client.session.Batch(ctx, ConsumeVerificationSetOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[ConsumeVerificationSetOutcome]{}, err }; result := BatchResult[ConsumeVerificationSetOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[ConsumeVerificationSetOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[ConsumeVerificationSetOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeConsumeVerificationSetOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[ConsumeVerificationSetOutcome]{}, decodeErr }; converted.Result = &CommandResult[ConsumeVerificationSetOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: ConsumeVerificationSetPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) ConsumeVerificationSet(ctx context.Context, input ConsumeVerificationSetInput) (CommandResult[ConsumeVerificationSetOutcome], error) { if err := validateConsumeVerificationSetInput(input); err != nil { return CommandResult[ConsumeVerificationSetOutcome]{}, err }; response, err := client.session.Invoke(ctx, ConsumeVerificationSetOperation, encodeConsumeVerificationSetInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[ConsumeVerificationSetOutcome]{}, err }; outcome, err := decodeConsumeVerificationSetOutcome(response.Value); if err != nil { return CommandResult[ConsumeVerificationSetOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[ConsumeVerificationSetOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: ConsumeVerificationSetPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) ConsumeVerificationSetBatch(ctx context.Context, inputs []ConsumeVerificationSetInput, concurrency, checkpoint uint32) (BatchResult[ConsumeVerificationSetOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateConsumeVerificationSetInput(input); err != nil { return BatchResult[ConsumeVerificationSetOutcome]{}, err }; encoded[index] = encodeConsumeVerificationSetInput(input) }; response, err := client.session.Batch(ctx, ConsumeVerificationSetOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[ConsumeVerificationSetOutcome]{}, err }; result := BatchResult[ConsumeVerificationSetOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[ConsumeVerificationSetOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[ConsumeVerificationSetOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeConsumeVerificationSetOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[ConsumeVerificationSetOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[ConsumeVerificationSetOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: ConsumeVerificationSetPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
+
+const ConsumeVerificationSnapshotPlanHash = "1a80a36f34b4699c972fc1e6f48cad3f85da54e202831a6986aea084db09788b"
+var ConsumeVerificationSnapshotOperation = riffdb.Operation{Name: "riffdb_better_auth_core_consume_verification_snapshot", InputSchemaHash: "d1ae264c5794d32e6619f9d52b77dd3a4cab39615dd48adb9a2a3b46ff92cd8c"}
+func encodeConsumeVerificationSnapshotInput(input ConsumeVerificationSnapshotInput) map[string]riffdb.Value { return map[string]riffdb.Value{
+	"request_id": riffdb.UUID(input.RequestId),
+	"organization_id": riffdb.UUID(input.OrganizationId),
+	"verification_id": riffdb.UUID(input.VerificationId),
+	"expected_revision": riffdb.U64(input.ExpectedRevision),
+} }
+func decodeConsumeVerificationSnapshotOutcome(value riffdb.Value) (ConsumeVerificationSnapshotOutcome, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; switch outcome {
+case "VerificationConsumed": result := ConsumeVerificationSnapshotVerificationConsumed{Outcome: outcome}
+return result, nil
+case "VerificationConsumeStale": result := ConsumeVerificationSnapshotVerificationConsumeStale{Outcome: outcome}
+return result, nil
+case "VerificationConsumeMissing": result := ConsumeVerificationSnapshotVerificationConsumeMissing{Outcome: outcome}
+return result, nil
+default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
+func (client *Client) ConsumeVerificationSnapshot(ctx context.Context, input ConsumeVerificationSnapshotInput) (CommandResult[ConsumeVerificationSnapshotOutcome], error) { response, err := client.session.Invoke(ctx, ConsumeVerificationSnapshotOperation, encodeConsumeVerificationSnapshotInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[ConsumeVerificationSnapshotOutcome]{}, err }; outcome, err := decodeConsumeVerificationSnapshotOutcome(response.Value); if err != nil { return CommandResult[ConsumeVerificationSnapshotOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[ConsumeVerificationSnapshotOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: ConsumeVerificationSnapshotPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) ConsumeVerificationSnapshotBatch(ctx context.Context, inputs []ConsumeVerificationSnapshotInput, concurrency, checkpoint uint32) (BatchResult[ConsumeVerificationSnapshotOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeConsumeVerificationSnapshotInput(input) }; response, err := client.session.Batch(ctx, ConsumeVerificationSnapshotOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[ConsumeVerificationSnapshotOutcome]{}, err }; result := BatchResult[ConsumeVerificationSnapshotOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[ConsumeVerificationSnapshotOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[ConsumeVerificationSnapshotOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeConsumeVerificationSnapshotOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[ConsumeVerificationSnapshotOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[ConsumeVerificationSnapshotOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: ConsumeVerificationSnapshotPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const CreateAccountPlanHash = "53f2e7b330780eb514a299ceb673da4f1eeaea81beb45253267a52e41a7fd0b2"
 var CreateAccountOperation = riffdb.Operation{Name: "riffdb_better_auth_core_create_account", InputSchemaHash: "9f59abcc35f23822a34f3504905acaae3df3c62c0f60e6bcb65bd8768279c4f9"}
@@ -1653,8 +1833,9 @@ return result, nil
 case "AccountAlreadyExists": result := CreateAccountAccountAlreadyExists{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) CreateAccount(ctx context.Context, input CreateAccountInput) (CommandResult[CreateAccountOutcome], error) { response, err := client.session.Invoke(ctx, CreateAccountOperation, encodeCreateAccountInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateAccountOutcome]{}, err }; outcome, err := decodeCreateAccountOutcome(response.Value); if err != nil { return CommandResult[CreateAccountOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[CreateAccountOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateAccountPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) CreateAccountBatch(ctx context.Context, inputs []CreateAccountInput, concurrency, checkpoint uint32) (BatchResult[CreateAccountOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateAccountInput(input) }; response, err := client.session.Batch(ctx, CreateAccountOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateAccountOutcome]{}, err }; result := BatchResult[CreateAccountOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateAccountOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateAccountOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateAccountOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateAccountOutcome]{}, decodeErr }; converted.Result = &CommandResult[CreateAccountOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateAccountPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) CreateAccount(ctx context.Context, input CreateAccountInput) (CommandResult[CreateAccountOutcome], error) { response, err := client.session.Invoke(ctx, CreateAccountOperation, encodeCreateAccountInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateAccountOutcome]{}, err }; outcome, err := decodeCreateAccountOutcome(response.Value); if err != nil { return CommandResult[CreateAccountOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[CreateAccountOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateAccountPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) CreateAccountBatch(ctx context.Context, inputs []CreateAccountInput, concurrency, checkpoint uint32) (BatchResult[CreateAccountOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateAccountInput(input) }; response, err := client.session.Batch(ctx, CreateAccountOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateAccountOutcome]{}, err }; result := BatchResult[CreateAccountOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateAccountOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateAccountOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateAccountOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateAccountOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[CreateAccountOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateAccountPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const CreateOAuthUserGraphPlanHash = "a30c6faca9666ff17536e1f4ec35f0306e970430a064e0d72a66adccefad7407"
 var CreateOAuthUserGraphOperation = riffdb.Operation{Name: "riffdb_better_auth_core_create_o_auth_user_graph", InputSchemaHash: "e7b044ec8cfadc80fc33bc06825e721bc65d5926299b0643cf1f7e4e75cf6f33"}
@@ -1689,8 +1870,9 @@ return result, nil
 case "OAuthUserGraphCreated": result := CreateOAuthUserGraphOAuthUserGraphCreated{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) CreateOAuthUserGraph(ctx context.Context, input CreateOAuthUserGraphInput) (CommandResult[CreateOAuthUserGraphOutcome], error) { response, err := client.session.Invoke(ctx, CreateOAuthUserGraphOperation, encodeCreateOAuthUserGraphInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateOAuthUserGraphOutcome]{}, err }; outcome, err := decodeCreateOAuthUserGraphOutcome(response.Value); if err != nil { return CommandResult[CreateOAuthUserGraphOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[CreateOAuthUserGraphOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateOAuthUserGraphPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) CreateOAuthUserGraphBatch(ctx context.Context, inputs []CreateOAuthUserGraphInput, concurrency, checkpoint uint32) (BatchResult[CreateOAuthUserGraphOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateOAuthUserGraphInput(input) }; response, err := client.session.Batch(ctx, CreateOAuthUserGraphOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateOAuthUserGraphOutcome]{}, err }; result := BatchResult[CreateOAuthUserGraphOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateOAuthUserGraphOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateOAuthUserGraphOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateOAuthUserGraphOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateOAuthUserGraphOutcome]{}, decodeErr }; converted.Result = &CommandResult[CreateOAuthUserGraphOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateOAuthUserGraphPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) CreateOAuthUserGraph(ctx context.Context, input CreateOAuthUserGraphInput) (CommandResult[CreateOAuthUserGraphOutcome], error) { response, err := client.session.Invoke(ctx, CreateOAuthUserGraphOperation, encodeCreateOAuthUserGraphInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateOAuthUserGraphOutcome]{}, err }; outcome, err := decodeCreateOAuthUserGraphOutcome(response.Value); if err != nil { return CommandResult[CreateOAuthUserGraphOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[CreateOAuthUserGraphOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateOAuthUserGraphPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) CreateOAuthUserGraphBatch(ctx context.Context, inputs []CreateOAuthUserGraphInput, concurrency, checkpoint uint32) (BatchResult[CreateOAuthUserGraphOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateOAuthUserGraphInput(input) }; response, err := client.session.Batch(ctx, CreateOAuthUserGraphOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateOAuthUserGraphOutcome]{}, err }; result := BatchResult[CreateOAuthUserGraphOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateOAuthUserGraphOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateOAuthUserGraphOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateOAuthUserGraphOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateOAuthUserGraphOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[CreateOAuthUserGraphOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateOAuthUserGraphPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const CreateSessionPlanHash = "c5e41496adb0a45f87503008fa43da87c6c729674bb1f521625ff16183059050"
 var CreateSessionOperation = riffdb.Operation{Name: "riffdb_better_auth_core_create_session", InputSchemaHash: "90f15b4cdb6f49df5e37b625173a07170d7975bbb4e8a8d1419071cd4f8a9312"}
@@ -1714,8 +1896,9 @@ return result, nil
 case "SessionAlreadyExists": result := CreateSessionSessionAlreadyExists{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) CreateSession(ctx context.Context, input CreateSessionInput) (CommandResult[CreateSessionOutcome], error) { response, err := client.session.Invoke(ctx, CreateSessionOperation, encodeCreateSessionInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateSessionOutcome]{}, err }; outcome, err := decodeCreateSessionOutcome(response.Value); if err != nil { return CommandResult[CreateSessionOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[CreateSessionOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateSessionPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) CreateSessionBatch(ctx context.Context, inputs []CreateSessionInput, concurrency, checkpoint uint32) (BatchResult[CreateSessionOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateSessionInput(input) }; response, err := client.session.Batch(ctx, CreateSessionOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateSessionOutcome]{}, err }; result := BatchResult[CreateSessionOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateSessionOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateSessionOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateSessionOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateSessionOutcome]{}, decodeErr }; converted.Result = &CommandResult[CreateSessionOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateSessionPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) CreateSession(ctx context.Context, input CreateSessionInput) (CommandResult[CreateSessionOutcome], error) { response, err := client.session.Invoke(ctx, CreateSessionOperation, encodeCreateSessionInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateSessionOutcome]{}, err }; outcome, err := decodeCreateSessionOutcome(response.Value); if err != nil { return CommandResult[CreateSessionOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[CreateSessionOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateSessionPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) CreateSessionBatch(ctx context.Context, inputs []CreateSessionInput, concurrency, checkpoint uint32) (BatchResult[CreateSessionOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateSessionInput(input) }; response, err := client.session.Batch(ctx, CreateSessionOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateSessionOutcome]{}, err }; result := BatchResult[CreateSessionOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateSessionOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateSessionOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateSessionOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateSessionOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[CreateSessionOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateSessionPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const CreateSignupGraphPlanHash = "01e4e118b1cc5c3a16c19259284cd0845e8a2e405fc02f81ab9b1fcafc79d0b8"
 var CreateSignupGraphOperation = riffdb.Operation{Name: "riffdb_better_auth_core_create_signup_graph", InputSchemaHash: "49ab048473688615ee1dd52f54c399de0a8da4accab6a7e8f109b3bdd0937c31"}
@@ -1753,8 +1936,9 @@ return result, nil
 case "SignupSessionExists": result := CreateSignupGraphSignupSessionExists{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) CreateSignupGraph(ctx context.Context, input CreateSignupGraphInput) (CommandResult[CreateSignupGraphOutcome], error) { response, err := client.session.Invoke(ctx, CreateSignupGraphOperation, encodeCreateSignupGraphInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateSignupGraphOutcome]{}, err }; outcome, err := decodeCreateSignupGraphOutcome(response.Value); if err != nil { return CommandResult[CreateSignupGraphOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[CreateSignupGraphOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateSignupGraphPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) CreateSignupGraphBatch(ctx context.Context, inputs []CreateSignupGraphInput, concurrency, checkpoint uint32) (BatchResult[CreateSignupGraphOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateSignupGraphInput(input) }; response, err := client.session.Batch(ctx, CreateSignupGraphOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateSignupGraphOutcome]{}, err }; result := BatchResult[CreateSignupGraphOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateSignupGraphOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateSignupGraphOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateSignupGraphOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateSignupGraphOutcome]{}, decodeErr }; converted.Result = &CommandResult[CreateSignupGraphOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateSignupGraphPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) CreateSignupGraph(ctx context.Context, input CreateSignupGraphInput) (CommandResult[CreateSignupGraphOutcome], error) { response, err := client.session.Invoke(ctx, CreateSignupGraphOperation, encodeCreateSignupGraphInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateSignupGraphOutcome]{}, err }; outcome, err := decodeCreateSignupGraphOutcome(response.Value); if err != nil { return CommandResult[CreateSignupGraphOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[CreateSignupGraphOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateSignupGraphPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) CreateSignupGraphBatch(ctx context.Context, inputs []CreateSignupGraphInput, concurrency, checkpoint uint32) (BatchResult[CreateSignupGraphOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateSignupGraphInput(input) }; response, err := client.session.Batch(ctx, CreateSignupGraphOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateSignupGraphOutcome]{}, err }; result := BatchResult[CreateSignupGraphOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateSignupGraphOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateSignupGraphOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateSignupGraphOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateSignupGraphOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[CreateSignupGraphOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateSignupGraphPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const CreateUserPlanHash = "752d7d404aa418b5c1a08065ce9a8efbb28ab2b62f18969c98a13a06092fd8b3"
 var CreateUserOperation = riffdb.Operation{Name: "riffdb_better_auth_core_create_user", InputSchemaHash: "797c4a05358287284cac08b3b955bda7d19f1fb1fd7d682d3daf07b12d64ea2a"}
@@ -1775,8 +1959,9 @@ return result, nil
 case "UserAlreadyExists": result := CreateUserUserAlreadyExists{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) CreateUser(ctx context.Context, input CreateUserInput) (CommandResult[CreateUserOutcome], error) { response, err := client.session.Invoke(ctx, CreateUserOperation, encodeCreateUserInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateUserOutcome]{}, err }; outcome, err := decodeCreateUserOutcome(response.Value); if err != nil { return CommandResult[CreateUserOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[CreateUserOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateUserPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) CreateUserBatch(ctx context.Context, inputs []CreateUserInput, concurrency, checkpoint uint32) (BatchResult[CreateUserOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateUserInput(input) }; response, err := client.session.Batch(ctx, CreateUserOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateUserOutcome]{}, err }; result := BatchResult[CreateUserOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateUserOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateUserOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateUserOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateUserOutcome]{}, decodeErr }; converted.Result = &CommandResult[CreateUserOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateUserPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) CreateUser(ctx context.Context, input CreateUserInput) (CommandResult[CreateUserOutcome], error) { response, err := client.session.Invoke(ctx, CreateUserOperation, encodeCreateUserInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateUserOutcome]{}, err }; outcome, err := decodeCreateUserOutcome(response.Value); if err != nil { return CommandResult[CreateUserOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[CreateUserOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateUserPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) CreateUserBatch(ctx context.Context, inputs []CreateUserInput, concurrency, checkpoint uint32) (BatchResult[CreateUserOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateUserInput(input) }; response, err := client.session.Batch(ctx, CreateUserOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateUserOutcome]{}, err }; result := BatchResult[CreateUserOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateUserOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateUserOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateUserOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateUserOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[CreateUserOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateUserPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const CreateVerificationPlanHash = "82bce005457b1fcf1d069a69304f7bf4e2eeb7d2718d5289dc9d25e197309e35"
 var CreateVerificationOperation = riffdb.Operation{Name: "riffdb_better_auth_core_create_verification", InputSchemaHash: "1df4414485ef2e463cee868bb97850b7a189a8c72c6090a650a1a1e0bd96baef"}
@@ -1796,8 +1981,9 @@ return result, nil
 case "VerificationAlreadyExists": result := CreateVerificationVerificationAlreadyExists{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) CreateVerification(ctx context.Context, input CreateVerificationInput) (CommandResult[CreateVerificationOutcome], error) { response, err := client.session.Invoke(ctx, CreateVerificationOperation, encodeCreateVerificationInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateVerificationOutcome]{}, err }; outcome, err := decodeCreateVerificationOutcome(response.Value); if err != nil { return CommandResult[CreateVerificationOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[CreateVerificationOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateVerificationPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) CreateVerificationBatch(ctx context.Context, inputs []CreateVerificationInput, concurrency, checkpoint uint32) (BatchResult[CreateVerificationOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateVerificationInput(input) }; response, err := client.session.Batch(ctx, CreateVerificationOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateVerificationOutcome]{}, err }; result := BatchResult[CreateVerificationOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateVerificationOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateVerificationOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateVerificationOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateVerificationOutcome]{}, decodeErr }; converted.Result = &CommandResult[CreateVerificationOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateVerificationPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) CreateVerification(ctx context.Context, input CreateVerificationInput) (CommandResult[CreateVerificationOutcome], error) { response, err := client.session.Invoke(ctx, CreateVerificationOperation, encodeCreateVerificationInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[CreateVerificationOutcome]{}, err }; outcome, err := decodeCreateVerificationOutcome(response.Value); if err != nil { return CommandResult[CreateVerificationOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[CreateVerificationOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: CreateVerificationPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) CreateVerificationBatch(ctx context.Context, inputs []CreateVerificationInput, concurrency, checkpoint uint32) (BatchResult[CreateVerificationOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeCreateVerificationInput(input) }; response, err := client.session.Batch(ctx, CreateVerificationOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[CreateVerificationOutcome]{}, err }; result := BatchResult[CreateVerificationOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[CreateVerificationOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[CreateVerificationOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeCreateVerificationOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[CreateVerificationOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[CreateVerificationOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: CreateVerificationPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const DeleteAccountPlanHash = "6429ebe6e70797c57c44a4738c8a511bbe5304e5bf58148dfc0c2721ffaff382"
 var DeleteAccountOperation = riffdb.Operation{Name: "riffdb_better_auth_core_delete_account", InputSchemaHash: "8e512e4d77b1ced01a098641ce940e1440a4b63d4c3e2ddad9068a1faf9c2c11"}
@@ -1814,8 +2000,9 @@ return result, nil
 case "AccountMissing": result := DeleteAccountAccountMissing{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) DeleteAccount(ctx context.Context, input DeleteAccountInput) (CommandResult[DeleteAccountOutcome], error) { if err := validateDeleteAccountInput(input); err != nil { return CommandResult[DeleteAccountOutcome]{}, err }; response, err := client.session.Invoke(ctx, DeleteAccountOperation, encodeDeleteAccountInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[DeleteAccountOutcome]{}, err }; outcome, err := decodeDeleteAccountOutcome(response.Value); if err != nil { return CommandResult[DeleteAccountOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[DeleteAccountOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: DeleteAccountPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) DeleteAccountBatch(ctx context.Context, inputs []DeleteAccountInput, concurrency, checkpoint uint32) (BatchResult[DeleteAccountOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateDeleteAccountInput(input); err != nil { return BatchResult[DeleteAccountOutcome]{}, err }; encoded[index] = encodeDeleteAccountInput(input) }; response, err := client.session.Batch(ctx, DeleteAccountOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[DeleteAccountOutcome]{}, err }; result := BatchResult[DeleteAccountOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[DeleteAccountOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[DeleteAccountOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeDeleteAccountOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[DeleteAccountOutcome]{}, decodeErr }; converted.Result = &CommandResult[DeleteAccountOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: DeleteAccountPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) DeleteAccount(ctx context.Context, input DeleteAccountInput) (CommandResult[DeleteAccountOutcome], error) { if err := validateDeleteAccountInput(input); err != nil { return CommandResult[DeleteAccountOutcome]{}, err }; response, err := client.session.Invoke(ctx, DeleteAccountOperation, encodeDeleteAccountInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[DeleteAccountOutcome]{}, err }; outcome, err := decodeDeleteAccountOutcome(response.Value); if err != nil { return CommandResult[DeleteAccountOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[DeleteAccountOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: DeleteAccountPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) DeleteAccountBatch(ctx context.Context, inputs []DeleteAccountInput, concurrency, checkpoint uint32) (BatchResult[DeleteAccountOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateDeleteAccountInput(input); err != nil { return BatchResult[DeleteAccountOutcome]{}, err }; encoded[index] = encodeDeleteAccountInput(input) }; response, err := client.session.Batch(ctx, DeleteAccountOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[DeleteAccountOutcome]{}, err }; result := BatchResult[DeleteAccountOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[DeleteAccountOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[DeleteAccountOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeDeleteAccountOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[DeleteAccountOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[DeleteAccountOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: DeleteAccountPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const DeleteSessionPlanHash = "a3901beb6c2d2754fd3d2c64252b6f5059cd1792c0a0560741c94da4668a0524"
 var DeleteSessionOperation = riffdb.Operation{Name: "riffdb_better_auth_core_delete_session", InputSchemaHash: "6eeb9f3b452bb70a9b0e955dcb9e9a0115db479f3297a5d3c8b243a6e34974f7"}
@@ -1832,8 +2019,9 @@ return result, nil
 case "SessionMissing": result := DeleteSessionSessionMissing{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) DeleteSession(ctx context.Context, input DeleteSessionInput) (CommandResult[DeleteSessionOutcome], error) { if err := validateDeleteSessionInput(input); err != nil { return CommandResult[DeleteSessionOutcome]{}, err }; response, err := client.session.Invoke(ctx, DeleteSessionOperation, encodeDeleteSessionInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[DeleteSessionOutcome]{}, err }; outcome, err := decodeDeleteSessionOutcome(response.Value); if err != nil { return CommandResult[DeleteSessionOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[DeleteSessionOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: DeleteSessionPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) DeleteSessionBatch(ctx context.Context, inputs []DeleteSessionInput, concurrency, checkpoint uint32) (BatchResult[DeleteSessionOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateDeleteSessionInput(input); err != nil { return BatchResult[DeleteSessionOutcome]{}, err }; encoded[index] = encodeDeleteSessionInput(input) }; response, err := client.session.Batch(ctx, DeleteSessionOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[DeleteSessionOutcome]{}, err }; result := BatchResult[DeleteSessionOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[DeleteSessionOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[DeleteSessionOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeDeleteSessionOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[DeleteSessionOutcome]{}, decodeErr }; converted.Result = &CommandResult[DeleteSessionOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: DeleteSessionPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) DeleteSession(ctx context.Context, input DeleteSessionInput) (CommandResult[DeleteSessionOutcome], error) { if err := validateDeleteSessionInput(input); err != nil { return CommandResult[DeleteSessionOutcome]{}, err }; response, err := client.session.Invoke(ctx, DeleteSessionOperation, encodeDeleteSessionInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[DeleteSessionOutcome]{}, err }; outcome, err := decodeDeleteSessionOutcome(response.Value); if err != nil { return CommandResult[DeleteSessionOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[DeleteSessionOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: DeleteSessionPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) DeleteSessionBatch(ctx context.Context, inputs []DeleteSessionInput, concurrency, checkpoint uint32) (BatchResult[DeleteSessionOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateDeleteSessionInput(input); err != nil { return BatchResult[DeleteSessionOutcome]{}, err }; encoded[index] = encodeDeleteSessionInput(input) }; response, err := client.session.Batch(ctx, DeleteSessionOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[DeleteSessionOutcome]{}, err }; result := BatchResult[DeleteSessionOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[DeleteSessionOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[DeleteSessionOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeDeleteSessionOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[DeleteSessionOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[DeleteSessionOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: DeleteSessionPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const DeleteUserPlanHash = "f7195857c4f50a68b37ee0f8516c27dd03b08d5cd5ba45f53d9f9345d2f90985"
 var DeleteUserOperation = riffdb.Operation{Name: "riffdb_better_auth_core_delete_user", InputSchemaHash: "c128e0333c57f08e3094e68459abbac53483952520e8381c0b79db903c36146d"}
@@ -1851,8 +2039,9 @@ return result, nil
 case "DeleteUserCascadeLimitExceeded": result := DeleteUserDeleteUserCascadeLimitExceeded{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) DeleteUser(ctx context.Context, input DeleteUserInput) (CommandResult[DeleteUserOutcome], error) { if err := validateDeleteUserInput(input); err != nil { return CommandResult[DeleteUserOutcome]{}, err }; response, err := client.session.Invoke(ctx, DeleteUserOperation, encodeDeleteUserInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[DeleteUserOutcome]{}, err }; outcome, err := decodeDeleteUserOutcome(response.Value); if err != nil { return CommandResult[DeleteUserOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[DeleteUserOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: DeleteUserPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) DeleteUserBatch(ctx context.Context, inputs []DeleteUserInput, concurrency, checkpoint uint32) (BatchResult[DeleteUserOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateDeleteUserInput(input); err != nil { return BatchResult[DeleteUserOutcome]{}, err }; encoded[index] = encodeDeleteUserInput(input) }; response, err := client.session.Batch(ctx, DeleteUserOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[DeleteUserOutcome]{}, err }; result := BatchResult[DeleteUserOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[DeleteUserOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[DeleteUserOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeDeleteUserOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[DeleteUserOutcome]{}, decodeErr }; converted.Result = &CommandResult[DeleteUserOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: DeleteUserPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) DeleteUser(ctx context.Context, input DeleteUserInput) (CommandResult[DeleteUserOutcome], error) { if err := validateDeleteUserInput(input); err != nil { return CommandResult[DeleteUserOutcome]{}, err }; response, err := client.session.Invoke(ctx, DeleteUserOperation, encodeDeleteUserInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[DeleteUserOutcome]{}, err }; outcome, err := decodeDeleteUserOutcome(response.Value); if err != nil { return CommandResult[DeleteUserOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[DeleteUserOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: DeleteUserPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) DeleteUserBatch(ctx context.Context, inputs []DeleteUserInput, concurrency, checkpoint uint32) (BatchResult[DeleteUserOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateDeleteUserInput(input); err != nil { return BatchResult[DeleteUserOutcome]{}, err }; encoded[index] = encodeDeleteUserInput(input) }; response, err := client.session.Batch(ctx, DeleteUserOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[DeleteUserOutcome]{}, err }; result := BatchResult[DeleteUserOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[DeleteUserOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[DeleteUserOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeDeleteUserOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[DeleteUserOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[DeleteUserOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: DeleteUserPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const DeleteVerificationPlanHash = "bffc0c5ef5ad2b602954492d043e833785ec3f9d6f0520fbc0f933422544ae6a"
 var DeleteVerificationOperation = riffdb.Operation{Name: "riffdb_better_auth_core_delete_verification", InputSchemaHash: "ce88d8052f760625503f8a732f9813446ef7cc042d726ee1826c05c437c0929c"}
@@ -1868,8 +2057,42 @@ return result, nil
 case "VerificationMissing": result := DeleteVerificationVerificationMissing{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) DeleteVerification(ctx context.Context, input DeleteVerificationInput) (CommandResult[DeleteVerificationOutcome], error) { if err := validateDeleteVerificationInput(input); err != nil { return CommandResult[DeleteVerificationOutcome]{}, err }; response, err := client.session.Invoke(ctx, DeleteVerificationOperation, encodeDeleteVerificationInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[DeleteVerificationOutcome]{}, err }; outcome, err := decodeDeleteVerificationOutcome(response.Value); if err != nil { return CommandResult[DeleteVerificationOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[DeleteVerificationOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: DeleteVerificationPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) DeleteVerificationBatch(ctx context.Context, inputs []DeleteVerificationInput, concurrency, checkpoint uint32) (BatchResult[DeleteVerificationOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateDeleteVerificationInput(input); err != nil { return BatchResult[DeleteVerificationOutcome]{}, err }; encoded[index] = encodeDeleteVerificationInput(input) }; response, err := client.session.Batch(ctx, DeleteVerificationOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[DeleteVerificationOutcome]{}, err }; result := BatchResult[DeleteVerificationOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[DeleteVerificationOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[DeleteVerificationOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeDeleteVerificationOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[DeleteVerificationOutcome]{}, decodeErr }; converted.Result = &CommandResult[DeleteVerificationOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: DeleteVerificationPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) DeleteVerification(ctx context.Context, input DeleteVerificationInput) (CommandResult[DeleteVerificationOutcome], error) { if err := validateDeleteVerificationInput(input); err != nil { return CommandResult[DeleteVerificationOutcome]{}, err }; response, err := client.session.Invoke(ctx, DeleteVerificationOperation, encodeDeleteVerificationInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[DeleteVerificationOutcome]{}, err }; outcome, err := decodeDeleteVerificationOutcome(response.Value); if err != nil { return CommandResult[DeleteVerificationOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[DeleteVerificationOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: DeleteVerificationPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) DeleteVerificationBatch(ctx context.Context, inputs []DeleteVerificationInput, concurrency, checkpoint uint32) (BatchResult[DeleteVerificationOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateDeleteVerificationInput(input); err != nil { return BatchResult[DeleteVerificationOutcome]{}, err }; encoded[index] = encodeDeleteVerificationInput(input) }; response, err := client.session.Batch(ctx, DeleteVerificationOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[DeleteVerificationOutcome]{}, err }; result := BatchResult[DeleteVerificationOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[DeleteVerificationOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[DeleteVerificationOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeDeleteVerificationOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[DeleteVerificationOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[DeleteVerificationOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: DeleteVerificationPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
+
+const ResetCredentialPasswordPlanHash = "ed87f267831fb0823b0e9bbf51d7b302a715a95c0cea69faf7922c0e4e7f375e"
+var ResetCredentialPasswordOperation = riffdb.Operation{Name: "riffdb_better_auth_core_reset_credential_password", InputSchemaHash: "b9959320d1fe50eba09aa488169566453c4ed9a58c27a338455e204b7f0c708d"}
+func encodeResetCredentialPasswordInput(input ResetCredentialPasswordInput) map[string]riffdb.Value { return map[string]riffdb.Value{
+	"user_id": riffdb.UUID(input.UserId),
+	"password": riffdb.String(input.Password),
+	"account_id": riffdb.UUID(input.AccountId),
+	"request_id": riffdb.UUID(input.RequestId),
+	"updated_at": riffdb.TimestampFrom(input.UpdatedAt),
+	"organization_id": riffdb.UUID(input.OrganizationId),
+	"account_revision": riffdb.U64(input.AccountRevision),
+	"verification_ids": riffdb.Values(input.VerificationIds, func(item string) riffdb.Value { return riffdb.UUID(item) }),
+	"external_account_id": riffdb.String(input.ExternalAccountId),
+	"verification_revision": riffdb.U64(input.VerificationRevision),
+} }
+func validateResetCredentialPasswordInput(input ResetCredentialPasswordInput) error { if len(input.VerificationIds) < 1 || len(input.VerificationIds) > 1 { return errors.New("invalid bounded collection length for ResetCredentialPassword.verification_ids") }; return nil }
+func decodeResetCredentialPasswordOutcome(value riffdb.Value) (ResetCredentialPasswordOutcome, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; switch outcome {
+case "PasswordAccountStale": result := ResetCredentialPasswordPasswordAccountStale{Outcome: outcome}
+return result, nil
+case "PasswordAccountMissing": result := ResetCredentialPasswordPasswordAccountMissing{Outcome: outcome}
+return result, nil
+case "CredentialPasswordReset": result := ResetCredentialPasswordCredentialPasswordReset{Outcome: outcome}
+return result, nil
+case "PasswordProviderMismatch": result := ResetCredentialPasswordPasswordProviderMismatch{Outcome: outcome}
+return result, nil
+case "VerificationConsumeStale": result := ResetCredentialPasswordVerificationConsumeStale{Outcome: outcome}
+return result, nil
+case "VerificationConsumeMissing": result := ResetCredentialPasswordVerificationConsumeMissing{Outcome: outcome}
+return result, nil
+default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
+func (client *Client) ResetCredentialPassword(ctx context.Context, input ResetCredentialPasswordInput) (CommandResult[ResetCredentialPasswordOutcome], error) { if err := validateResetCredentialPasswordInput(input); err != nil { return CommandResult[ResetCredentialPasswordOutcome]{}, err }; response, err := client.session.Invoke(ctx, ResetCredentialPasswordOperation, encodeResetCredentialPasswordInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[ResetCredentialPasswordOutcome]{}, err }; outcome, err := decodeResetCredentialPasswordOutcome(response.Value); if err != nil { return CommandResult[ResetCredentialPasswordOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[ResetCredentialPasswordOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: ResetCredentialPasswordPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) ResetCredentialPasswordBatch(ctx context.Context, inputs []ResetCredentialPasswordInput, concurrency, checkpoint uint32) (BatchResult[ResetCredentialPasswordOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateResetCredentialPasswordInput(input); err != nil { return BatchResult[ResetCredentialPasswordOutcome]{}, err }; encoded[index] = encodeResetCredentialPasswordInput(input) }; response, err := client.session.Batch(ctx, ResetCredentialPasswordOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[ResetCredentialPasswordOutcome]{}, err }; result := BatchResult[ResetCredentialPasswordOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[ResetCredentialPasswordOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[ResetCredentialPasswordOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeResetCredentialPasswordOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[ResetCredentialPasswordOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[ResetCredentialPasswordOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: ResetCredentialPasswordPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const UpdateAccountPlanHash = "1556cd92effd135225904f0313f1cdf146ebe82f72621ebeccb2686c5442b849"
 var UpdateAccountOperation = riffdb.Operation{Name: "riffdb_better_auth_core_update_account", InputSchemaHash: "f623666040b60333eba3b4b46d5b1fe92158fcade5037f13b8ed0435e5c9471e"}
@@ -1898,8 +2121,9 @@ return result, nil
 case "AccountUpdateMissing": result := UpdateAccountAccountUpdateMissing{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) UpdateAccount(ctx context.Context, input UpdateAccountInput) (CommandResult[UpdateAccountOutcome], error) { response, err := client.session.Invoke(ctx, UpdateAccountOperation, encodeUpdateAccountInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[UpdateAccountOutcome]{}, err }; outcome, err := decodeUpdateAccountOutcome(response.Value); if err != nil { return CommandResult[UpdateAccountOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[UpdateAccountOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: UpdateAccountPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) UpdateAccountBatch(ctx context.Context, inputs []UpdateAccountInput, concurrency, checkpoint uint32) (BatchResult[UpdateAccountOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeUpdateAccountInput(input) }; response, err := client.session.Batch(ctx, UpdateAccountOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[UpdateAccountOutcome]{}, err }; result := BatchResult[UpdateAccountOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[UpdateAccountOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[UpdateAccountOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeUpdateAccountOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[UpdateAccountOutcome]{}, decodeErr }; converted.Result = &CommandResult[UpdateAccountOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: UpdateAccountPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) UpdateAccount(ctx context.Context, input UpdateAccountInput) (CommandResult[UpdateAccountOutcome], error) { response, err := client.session.Invoke(ctx, UpdateAccountOperation, encodeUpdateAccountInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[UpdateAccountOutcome]{}, err }; outcome, err := decodeUpdateAccountOutcome(response.Value); if err != nil { return CommandResult[UpdateAccountOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[UpdateAccountOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: UpdateAccountPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) UpdateAccountBatch(ctx context.Context, inputs []UpdateAccountInput, concurrency, checkpoint uint32) (BatchResult[UpdateAccountOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeUpdateAccountInput(input) }; response, err := client.session.Batch(ctx, UpdateAccountOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[UpdateAccountOutcome]{}, err }; result := BatchResult[UpdateAccountOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[UpdateAccountOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[UpdateAccountOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeUpdateAccountOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[UpdateAccountOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[UpdateAccountOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: UpdateAccountPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const UpdateAccountPasswordsPlanHash = "5f18c741b5e9c09203c67b5985af9d034fad670462ecdda32a0a1f031ef288f6"
 var UpdateAccountPasswordsOperation = riffdb.Operation{Name: "riffdb_better_auth_core_update_account_passwords", InputSchemaHash: "f210cf13f349297bad0bd949bdfbb796e37ea4dfa24b99d6205942afdde0883c"}
@@ -1920,8 +2144,35 @@ return result, nil
 case "PasswordProviderMismatch": result := UpdateAccountPasswordsPasswordProviderMismatch{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) UpdateAccountPasswords(ctx context.Context, input UpdateAccountPasswordsInput) (CommandResult[UpdateAccountPasswordsOutcome], error) { if err := validateUpdateAccountPasswordsInput(input); err != nil { return CommandResult[UpdateAccountPasswordsOutcome]{}, err }; response, err := client.session.Invoke(ctx, UpdateAccountPasswordsOperation, encodeUpdateAccountPasswordsInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[UpdateAccountPasswordsOutcome]{}, err }; outcome, err := decodeUpdateAccountPasswordsOutcome(response.Value); if err != nil { return CommandResult[UpdateAccountPasswordsOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[UpdateAccountPasswordsOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: UpdateAccountPasswordsPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) UpdateAccountPasswordsBatch(ctx context.Context, inputs []UpdateAccountPasswordsInput, concurrency, checkpoint uint32) (BatchResult[UpdateAccountPasswordsOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateUpdateAccountPasswordsInput(input); err != nil { return BatchResult[UpdateAccountPasswordsOutcome]{}, err }; encoded[index] = encodeUpdateAccountPasswordsInput(input) }; response, err := client.session.Batch(ctx, UpdateAccountPasswordsOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[UpdateAccountPasswordsOutcome]{}, err }; result := BatchResult[UpdateAccountPasswordsOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[UpdateAccountPasswordsOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[UpdateAccountPasswordsOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeUpdateAccountPasswordsOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[UpdateAccountPasswordsOutcome]{}, decodeErr }; converted.Result = &CommandResult[UpdateAccountPasswordsOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: UpdateAccountPasswordsPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) UpdateAccountPasswords(ctx context.Context, input UpdateAccountPasswordsInput) (CommandResult[UpdateAccountPasswordsOutcome], error) { if err := validateUpdateAccountPasswordsInput(input); err != nil { return CommandResult[UpdateAccountPasswordsOutcome]{}, err }; response, err := client.session.Invoke(ctx, UpdateAccountPasswordsOperation, encodeUpdateAccountPasswordsInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[UpdateAccountPasswordsOutcome]{}, err }; outcome, err := decodeUpdateAccountPasswordsOutcome(response.Value); if err != nil { return CommandResult[UpdateAccountPasswordsOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[UpdateAccountPasswordsOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: UpdateAccountPasswordsPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) UpdateAccountPasswordsBatch(ctx context.Context, inputs []UpdateAccountPasswordsInput, concurrency, checkpoint uint32) (BatchResult[UpdateAccountPasswordsOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { if err := validateUpdateAccountPasswordsInput(input); err != nil { return BatchResult[UpdateAccountPasswordsOutcome]{}, err }; encoded[index] = encodeUpdateAccountPasswordsInput(input) }; response, err := client.session.Batch(ctx, UpdateAccountPasswordsOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[UpdateAccountPasswordsOutcome]{}, err }; result := BatchResult[UpdateAccountPasswordsOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[UpdateAccountPasswordsOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[UpdateAccountPasswordsOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeUpdateAccountPasswordsOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[UpdateAccountPasswordsOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[UpdateAccountPasswordsOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: UpdateAccountPasswordsPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
+
+const UpdateCredentialPasswordPlanHash = "08781a68739c705ab6ffe51a0de547605e1a7dd2fd2b8075445d40db923d1f15"
+var UpdateCredentialPasswordOperation = riffdb.Operation{Name: "riffdb_better_auth_core_update_credential_password", InputSchemaHash: "5d4589d948081b8f0d4472fa359bd34ca0c05895eac4e6a99f9015f8f45cc2e7"}
+func encodeUpdateCredentialPasswordInput(input UpdateCredentialPasswordInput) map[string]riffdb.Value { return map[string]riffdb.Value{
+	"user_id": riffdb.UUID(input.UserId),
+	"password": riffdb.String(input.Password),
+	"account_id": riffdb.UUID(input.AccountId),
+	"request_id": riffdb.UUID(input.RequestId),
+	"updated_at": riffdb.TimestampFrom(input.UpdatedAt),
+	"organization_id": riffdb.UUID(input.OrganizationId),
+	"expected_revision": riffdb.U64(input.ExpectedRevision),
+	"external_account_id": riffdb.String(input.ExternalAccountId),
+} }
+func decodeUpdateCredentialPasswordOutcome(value riffdb.Value) (UpdateCredentialPasswordOutcome, error) { fields, err := riffdb.RecordFields(value); if err != nil { return nil, err }; outcomeValue, err := requiredField(fields, "outcome"); if err != nil { return nil, err }; outcome, err := riffdb.EnumValue(outcomeValue); if err != nil { return nil, err }; switch outcome {
+case "PasswordAccountStale": result := UpdateCredentialPasswordPasswordAccountStale{Outcome: outcome}
+return result, nil
+case "PasswordAccountMissing": result := UpdateCredentialPasswordPasswordAccountMissing{Outcome: outcome}
+return result, nil
+case "PasswordProviderMismatch": result := UpdateCredentialPasswordPasswordProviderMismatch{Outcome: outcome}
+return result, nil
+case "CredentialPasswordUpdated": result := UpdateCredentialPasswordCredentialPasswordUpdated{Outcome: outcome}
+return result, nil
+default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
+func (client *Client) UpdateCredentialPassword(ctx context.Context, input UpdateCredentialPasswordInput) (CommandResult[UpdateCredentialPasswordOutcome], error) { response, err := client.session.Invoke(ctx, UpdateCredentialPasswordOperation, encodeUpdateCredentialPasswordInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[UpdateCredentialPasswordOutcome]{}, err }; outcome, err := decodeUpdateCredentialPasswordOutcome(response.Value); if err != nil { return CommandResult[UpdateCredentialPasswordOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[UpdateCredentialPasswordOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: UpdateCredentialPasswordPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) UpdateCredentialPasswordBatch(ctx context.Context, inputs []UpdateCredentialPasswordInput, concurrency, checkpoint uint32) (BatchResult[UpdateCredentialPasswordOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeUpdateCredentialPasswordInput(input) }; response, err := client.session.Batch(ctx, UpdateCredentialPasswordOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[UpdateCredentialPasswordOutcome]{}, err }; result := BatchResult[UpdateCredentialPasswordOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[UpdateCredentialPasswordOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[UpdateCredentialPasswordOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeUpdateCredentialPasswordOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[UpdateCredentialPasswordOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[UpdateCredentialPasswordOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: UpdateCredentialPasswordPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const UpdateSessionPlanHash = "4c1184c5c0a1f8b8935a8b96204ad839afe84e1752f2ba24cdf63feef4f7ce3a"
 var UpdateSessionOperation = riffdb.Operation{Name: "riffdb_better_auth_core_update_session", InputSchemaHash: "4dc035dba6c54788232952ebe5eb225c8f1e8e542ea3b20ef188f85fbfb1a1a1"}
@@ -1944,8 +2195,9 @@ return result, nil
 case "SessionUpdateMissing": result := UpdateSessionSessionUpdateMissing{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) UpdateSession(ctx context.Context, input UpdateSessionInput) (CommandResult[UpdateSessionOutcome], error) { response, err := client.session.Invoke(ctx, UpdateSessionOperation, encodeUpdateSessionInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[UpdateSessionOutcome]{}, err }; outcome, err := decodeUpdateSessionOutcome(response.Value); if err != nil { return CommandResult[UpdateSessionOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[UpdateSessionOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: UpdateSessionPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) UpdateSessionBatch(ctx context.Context, inputs []UpdateSessionInput, concurrency, checkpoint uint32) (BatchResult[UpdateSessionOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeUpdateSessionInput(input) }; response, err := client.session.Batch(ctx, UpdateSessionOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[UpdateSessionOutcome]{}, err }; result := BatchResult[UpdateSessionOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[UpdateSessionOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[UpdateSessionOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeUpdateSessionOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[UpdateSessionOutcome]{}, decodeErr }; converted.Result = &CommandResult[UpdateSessionOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: UpdateSessionPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) UpdateSession(ctx context.Context, input UpdateSessionInput) (CommandResult[UpdateSessionOutcome], error) { response, err := client.session.Invoke(ctx, UpdateSessionOperation, encodeUpdateSessionInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[UpdateSessionOutcome]{}, err }; outcome, err := decodeUpdateSessionOutcome(response.Value); if err != nil { return CommandResult[UpdateSessionOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[UpdateSessionOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: UpdateSessionPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) UpdateSessionBatch(ctx context.Context, inputs []UpdateSessionInput, concurrency, checkpoint uint32) (BatchResult[UpdateSessionOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeUpdateSessionInput(input) }; response, err := client.session.Batch(ctx, UpdateSessionOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[UpdateSessionOutcome]{}, err }; result := BatchResult[UpdateSessionOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[UpdateSessionOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[UpdateSessionOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeUpdateSessionOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[UpdateSessionOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[UpdateSessionOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: UpdateSessionPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const UpdateUserPlanHash = "cd0d3c8108976d4b2413f41fd68791b3e9276a763787f40b82bef17219091194"
 var UpdateUserOperation = riffdb.Operation{Name: "riffdb_better_auth_core_update_user", InputSchemaHash: "1c26635c0abf32530ed895a1dd615ef00b0a9c9177fafb4adedd7de97f7f5757"}
@@ -1968,8 +2220,9 @@ return result, nil
 case "UserUpdateMissing": result := UpdateUserUserUpdateMissing{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) UpdateUser(ctx context.Context, input UpdateUserInput) (CommandResult[UpdateUserOutcome], error) { response, err := client.session.Invoke(ctx, UpdateUserOperation, encodeUpdateUserInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[UpdateUserOutcome]{}, err }; outcome, err := decodeUpdateUserOutcome(response.Value); if err != nil { return CommandResult[UpdateUserOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[UpdateUserOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: UpdateUserPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) UpdateUserBatch(ctx context.Context, inputs []UpdateUserInput, concurrency, checkpoint uint32) (BatchResult[UpdateUserOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeUpdateUserInput(input) }; response, err := client.session.Batch(ctx, UpdateUserOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[UpdateUserOutcome]{}, err }; result := BatchResult[UpdateUserOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[UpdateUserOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[UpdateUserOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeUpdateUserOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[UpdateUserOutcome]{}, decodeErr }; converted.Result = &CommandResult[UpdateUserOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: UpdateUserPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) UpdateUser(ctx context.Context, input UpdateUserInput) (CommandResult[UpdateUserOutcome], error) { response, err := client.session.Invoke(ctx, UpdateUserOperation, encodeUpdateUserInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[UpdateUserOutcome]{}, err }; outcome, err := decodeUpdateUserOutcome(response.Value); if err != nil { return CommandResult[UpdateUserOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[UpdateUserOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: UpdateUserPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) UpdateUserBatch(ctx context.Context, inputs []UpdateUserInput, concurrency, checkpoint uint32) (BatchResult[UpdateUserOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeUpdateUserInput(input) }; response, err := client.session.Batch(ctx, UpdateUserOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[UpdateUserOutcome]{}, err }; result := BatchResult[UpdateUserOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[UpdateUserOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[UpdateUserOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeUpdateUserOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[UpdateUserOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[UpdateUserOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: UpdateUserPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 const UpdateVerificationPlanHash = "b9ea963db584e7fd9dbce1069d982dc0f53ebb06b72b41b060578b284596018f"
 var UpdateVerificationOperation = riffdb.Operation{Name: "riffdb_better_auth_core_update_verification", InputSchemaHash: "4377bfd8aba7795661e686fbc5903e8116b2f9eba24bce9fcdd63cd4bb53e8c5"}
@@ -1990,7 +2243,8 @@ return result, nil
 case "VerificationUpdateMissing": result := UpdateVerificationVerificationUpdateMissing{Outcome: outcome}
 return result, nil
 default: return nil, errors.New("RiffDB driver returned unknown command outcome") } }
-func (client *Client) UpdateVerification(ctx context.Context, input UpdateVerificationInput) (CommandResult[UpdateVerificationOutcome], error) { response, err := client.session.Invoke(ctx, UpdateVerificationOperation, encodeUpdateVerificationInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[UpdateVerificationOutcome]{}, err }; outcome, err := decodeUpdateVerificationOutcome(response.Value); if err != nil { return CommandResult[UpdateVerificationOutcome]{}, err }; if client.trackCausalWrites && response.ApplicationHead != nil && *response.ApplicationHead > 0 && (client.readAfterCommit == nil || *response.ApplicationHead > *client.readAfterCommit) { commitSeq := *response.ApplicationHead; client.readAfterCommit = &commitSeq }; return CommandResult[UpdateVerificationOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: UpdateVerificationPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
-func (client *Client) UpdateVerificationBatch(ctx context.Context, inputs []UpdateVerificationInput, concurrency, checkpoint uint32) (BatchResult[UpdateVerificationOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeUpdateVerificationInput(input) }; response, err := client.session.Batch(ctx, UpdateVerificationOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[UpdateVerificationOutcome]{}, err }; result := BatchResult[UpdateVerificationOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[UpdateVerificationOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[UpdateVerificationOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeUpdateVerificationOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[UpdateVerificationOutcome]{}, decodeErr }; converted.Result = &CommandResult[UpdateVerificationOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: UpdateVerificationPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+func (client *Client) UpdateVerification(ctx context.Context, input UpdateVerificationInput) (CommandResult[UpdateVerificationOutcome], error) { response, err := client.session.Invoke(ctx, UpdateVerificationOperation, encodeUpdateVerificationInput(input), riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return CommandResult[UpdateVerificationOutcome]{}, err }; outcome, err := decodeUpdateVerificationOutcome(response.Value); if err != nil { return CommandResult[UpdateVerificationOutcome]{}, err }; client.observeCommit(response.ApplicationHead); return CommandResult[UpdateVerificationOutcome]{Outcome: outcome, CommitSequence: response.ApplicationHead, ContractVersion: ContractVersion, PlanHash: UpdateVerificationPlanHash, Replayed: response.Replayed, OutcomeURI: response.Cursor}, nil }
+func (client *Client) UpdateVerificationBatch(ctx context.Context, inputs []UpdateVerificationInput, concurrency, checkpoint uint32) (BatchResult[UpdateVerificationOutcome], error) { encoded := make([]map[string]riffdb.Value, len(inputs)); for index, input := range inputs { encoded[index] = encodeUpdateVerificationInput(input) }; response, err := client.session.Batch(ctx, UpdateVerificationOperation, encoded, concurrency, checkpoint, riffdb.Options{MaximumAttempts: client.commandAttempts}); if err != nil { return BatchResult[UpdateVerificationOutcome]{}, err }; result := BatchResult[UpdateVerificationOutcome]{Checkpoint: response.Checkpoint, Total: response.Total, Items: make([]BatchItem[UpdateVerificationOutcome], 0, len(response.Items))}; for _, item := range response.Items { converted := BatchItem[UpdateVerificationOutcome]{Index: item.Index}; if item.Error != nil { converted.Error = item.Error } else if item.Result != nil { outcome, decodeErr := decodeUpdateVerificationOutcome(item.Result.Value); if decodeErr != nil { return BatchResult[UpdateVerificationOutcome]{}, decodeErr }; client.observeCommit(item.Result.CommitSequence); converted.Result = &CommandResult[UpdateVerificationOutcome]{Outcome: outcome, CommitSequence: item.Result.CommitSequence, ContractVersion: ContractVersion, PlanHash: UpdateVerificationPlanHash, Replayed: item.Result.Replayed, OutcomeURI: item.Result.OutcomeURI} }; result.Items = append(result.Items, converted) }; return result, nil }
+
 
 func requiredField(fields map[string]riffdb.Value, name string) (riffdb.Value, error) { value, ok := fields[name]; if !ok { return riffdb.Value{}, errors.New("RiffDB driver result is missing a generated field") }; return value, nil }