dfns-sdk-rust 0.2.0

// Code generated by rust-sdk-generator. DO NOT EDIT.

#![allow(clippy::all)]

/// Create User Action Signature
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateUserActionSignatureRequest {
    #[serde(rename = "challengeIdentifier")]
    pub challenge_identifier: String,
    #[serde(rename = "firstFactor")]
    pub first_factor: serde_json::Value,
    #[serde(
        rename = "secondFactor",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub second_factor: Option<serde_json::Value>,
}

/// Create User Action Signature
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateUserActionSignatureResponse {
    #[serde(rename = "userAction")]
    pub user_action: String,
}

/// Create User Action Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateUserActionChallengeRequest {
    #[serde(
        rename = "userActionServerKind",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub user_action_server_kind: Option<String>,
    #[serde(rename = "userActionHttpMethod")]
    pub user_action_http_method: String,
    #[serde(rename = "userActionHttpPath")]
    pub user_action_http_path: String,
    #[serde(rename = "userActionPayload")]
    pub user_action_payload: String,
}

/// Create User Action Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateUserActionChallengeResponse {
    #[serde(rename = "challenge")]
    pub challenge: String,
    #[serde(rename = "challengeIdentifier")]
    pub challenge_identifier: String,
    #[serde(rename = "rp", default, skip_serializing_if = "Option::is_none")]
    pub rp: Option<serde_json::Value>,
    #[serde(rename = "supportedCredentialKinds")]
    pub supported_credential_kinds: Vec<serde_json::Value>,
    #[serde(rename = "userVerification")]
    pub user_verification: String,
    #[serde(rename = "attestation")]
    pub attestation: String,
    #[serde(rename = "allowCredentials")]
    pub allow_credentials: serde_json::Value,
    #[serde(rename = "externalAuthenticationUrl")]
    pub external_authentication_url: String,
}

/// Query parameters for the ListAuditLogsQuery operation.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ListAuditLogsQuery {
    #[serde(rename = "startTime")]
    pub start_time: String,
    #[serde(rename = "endTime")]
    pub end_time: String,
    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
    pub user_id: Option<String>,
}

/// Get Audit Log
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct GetAuditLogResponse {
    #[serde(rename = "id")]
    pub id: serde_json::Value,
    #[serde(rename = "action")]
    pub action: String,
    #[serde(rename = "actionToken")]
    pub action_token: String,
    #[serde(rename = "userId")]
    pub user_id: serde_json::Value,
    #[serde(rename = "username")]
    pub username: serde_json::Value,
    #[serde(rename = "datePerformed")]
    pub date_performed: String,
    #[serde(rename = "firstFactorCredential")]
    pub first_factor_credential: serde_json::Value,
}

/// List Applications
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ListApplicationsResponse {
    #[serde(rename = "items")]
    pub items: Vec<serde_json::Value>,
}

/// Get Application
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct GetApplicationResponse {
    #[serde(rename = "appId")]
    pub app_id: String,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "orgId")]
    pub org_id: String,
    #[serde(
        rename = "expectedRpId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub expected_rp_id: Option<String>,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(
        rename = "expectedOrigin",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub expected_origin: Option<String>,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
    #[serde(rename = "accessTokens")]
    pub access_tokens: Vec<crate::types::PersonalAccessToken>,
}

/// List Credentials
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ListCredentialsResponse {
    #[serde(rename = "items")]
    pub items: Vec<crate::types::Credential>,
}

/// Request body for the createCredential operation.
pub type CreateCredentialRequest = serde_json::Value;

/// Create Credential
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateCredentialResponse {
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "credentialId")]
    pub credential_id: String,
    #[serde(rename = "credentialUuid")]
    pub credential_uuid: String,
    #[serde(rename = "dateCreated")]
    pub date_created: String,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "publicKey")]
    pub public_key: String,
    #[serde(rename = "relyingPartyId")]
    pub relying_party_id: String,
    #[serde(rename = "origin")]
    pub origin: String,
}

/// Create Credential Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateCredentialChallengeRequest {
    #[serde(rename = "kind")]
    pub kind: crate::types::CredentialKind,
}

/// Activate Credential
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ActivateCredentialRequest {
    #[serde(rename = "credentialUuid")]
    pub credential_uuid: String,
}

/// Activate Credential
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ActivateCredentialResponse {
    #[serde(rename = "message")]
    pub message: String,
}

/// Delete Credential
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeleteCredentialResponse {}

/// Deactivate Credential
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeactivateCredentialRequest {
    #[serde(rename = "credentialUuid")]
    pub credential_uuid: String,
}

/// Deactivate Credential
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeactivateCredentialResponse {
    #[serde(rename = "message")]
    pub message: String,
}

/// Create Credential Code
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateCredentialCodeRequest {
    #[serde(rename = "expiration")]
    pub expiration: serde_json::Value,
}

/// Create Credential Code
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateCredentialCodeResponse {
    #[serde(rename = "code")]
    pub code: String,
    #[serde(rename = "expiration")]
    pub expiration: String,
}

/// Create Credential Challenge With Code
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateCredentialChallengeWithCodeRequest {
    #[serde(rename = "credentialKind")]
    pub credential_kind: String,
    #[serde(rename = "code")]
    pub code: String,
}

/// Request body for the createCredentialWithCode operation.
pub type CreateCredentialWithCodeRequest = serde_json::Value;

/// Create Credential With Code
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateCredentialWithCodeResponse {
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "credentialId")]
    pub credential_id: String,
    #[serde(rename = "credentialUuid")]
    pub credential_uuid: String,
    #[serde(rename = "dateCreated")]
    pub date_created: String,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "publicKey")]
    pub public_key: String,
    #[serde(rename = "relyingPartyId")]
    pub relying_party_id: String,
    #[serde(rename = "origin")]
    pub origin: String,
}

/// Create Login Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateLoginChallengeRequest {
    #[serde(rename = "username", default, skip_serializing_if = "Option::is_none")]
    pub username: Option<String>,
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(rename = "loginCode", default, skip_serializing_if = "Option::is_none")]
    pub login_code: Option<String>,
}

/// Create Login Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateLoginChallengeResponse {
    #[serde(rename = "challenge")]
    pub challenge: String,
    #[serde(rename = "challengeIdentifier")]
    pub challenge_identifier: String,
    #[serde(rename = "rp", default, skip_serializing_if = "Option::is_none")]
    pub rp: Option<serde_json::Value>,
    #[serde(rename = "supportedCredentialKinds")]
    pub supported_credential_kinds: Vec<serde_json::Value>,
    #[serde(rename = "userVerification")]
    pub user_verification: String,
    #[serde(rename = "attestation")]
    pub attestation: String,
    #[serde(rename = "allowCredentials")]
    pub allow_credentials: serde_json::Value,
    #[serde(rename = "externalAuthenticationUrl")]
    pub external_authentication_url: String,
}

/// Delegated Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DelegatedLoginRequest {
    #[serde(rename = "username")]
    pub username: String,
}

/// Delegated Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DelegatedLoginResponse {
    #[serde(rename = "token")]
    pub token: String,
}

/// Complete User Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CompleteUserLoginRequest {
    #[serde(rename = "challengeIdentifier")]
    pub challenge_identifier: String,
    #[serde(rename = "firstFactor")]
    pub first_factor: serde_json::Value,
    #[serde(
        rename = "secondFactor",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub second_factor: Option<serde_json::Value>,
}

/// Logout
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct LogoutRequest {
    #[serde(
        rename = "allSessions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub all_sessions: Option<bool>,
}

/// Logout
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct LogoutResponse {
    #[serde(rename = "message")]
    pub message: String,
}

/// Complete OIDC Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CompleteOidcLoginRequest {
    #[serde(rename = "code")]
    pub code: String,
    #[serde(rename = "state")]
    pub state: String,
}

/// Initiate OIDC Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct InitiateOidcLoginRequest {
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(rename = "redirectUri")]
    pub redirect_uri: String,
}

/// Initiate OIDC Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct InitiateOidcLoginResponse {
    #[serde(rename = "redirectUrl")]
    pub redirect_url: String,
}

/// Send Login Code
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct SendLoginCodeRequest {
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
}

/// Send Login Code
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct SendLoginCodeResponse {
    #[serde(rename = "message")]
    pub message: String,
}

/// Social Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct SocialLoginRequest {
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "socialLoginProviderKind")]
    pub social_login_provider_kind: String,
    #[serde(rename = "idToken")]
    pub id_token: String,
}

/// Social Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct SocialLoginResponse {
    #[serde(rename = "token")]
    pub token: String,
}

/// Complete SSO Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CompleteSsoLoginRequest {
    #[serde(rename = "code")]
    pub code: String,
    #[serde(rename = "state")]
    pub state: String,
}

/// Complete SSO Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CompleteSsoLoginResponse {
    #[serde(rename = "token")]
    pub token: String,
}

/// Initiate SSO Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct InitiateSsoLoginRequest {
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(rename = "clientId")]
    pub client_id: String,
    #[serde(rename = "redirectUri")]
    pub redirect_uri: String,
}

/// Initiate SSO Login
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct InitiateSsoLoginResponse {
    #[serde(rename = "ssoRedirectUrl")]
    pub sso_redirect_url: String,
}

/// Exchange Access Token
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ExchangeAccessTokenRequest {
    #[serde(rename = "target")]
    pub target: String,
}

/// Exchange Access Token
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ExchangeAccessTokenResponse {
    #[serde(rename = "token")]
    pub token: String,
}

/// List Personal Access Tokens
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ListPersonalAccessTokensResponse {
    #[serde(rename = "items")]
    pub items: Vec<crate::types::PersonalAccessToken>,
}

/// Create Personal Access Token
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreatePersonalAccessTokenRequest {
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "publicKey")]
    pub public_key: String,
    #[serde(
        rename = "permissionId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub permission_id: Option<String>,
    #[serde(
        rename = "externalId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub external_id: Option<String>,
    #[serde(rename = "daysValid", default, skip_serializing_if = "Option::is_none")]
    pub days_valid: Option<i64>,
    #[serde(
        rename = "secondsValid",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub seconds_valid: Option<i64>,
}

/// Create Personal Access Token
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreatePersonalAccessTokenResponse {
    #[serde(rename = "accessToken")]
    pub access_token: String,
    #[serde(rename = "dateCreated")]
    pub date_created: String,
    #[serde(rename = "credId")]
    pub cred_id: String,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "linkedUserId")]
    pub linked_user_id: String,
    #[serde(rename = "linkedAppId")]
    pub linked_app_id: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "orgId")]
    pub org_id: String,
    #[serde(rename = "publicKey")]
    pub public_key: String,
    #[serde(rename = "tokenId")]
    pub token_id: String,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
}

/// Get Personal Access Token
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct GetPersonalAccessTokenResponse {
    #[serde(
        rename = "accessToken",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub access_token: Option<String>,
    #[serde(rename = "dateCreated")]
    pub date_created: String,
    #[serde(rename = "credId")]
    pub cred_id: String,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "linkedUserId")]
    pub linked_user_id: String,
    #[serde(rename = "linkedAppId")]
    pub linked_app_id: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "orgId")]
    pub org_id: String,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
    #[serde(rename = "publicKey")]
    pub public_key: String,
    #[serde(rename = "tokenId")]
    pub token_id: String,
}

/// Update Personal Access Token
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct UpdatePersonalAccessTokenRequest {
    #[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(
        rename = "externalId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub external_id: Option<String>,
}

/// Update Personal Access Token
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct UpdatePersonalAccessTokenResponse {
    #[serde(
        rename = "accessToken",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub access_token: Option<String>,
    #[serde(rename = "dateCreated")]
    pub date_created: String,
    #[serde(rename = "credId")]
    pub cred_id: String,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "linkedUserId")]
    pub linked_user_id: String,
    #[serde(rename = "linkedAppId")]
    pub linked_app_id: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "orgId")]
    pub org_id: String,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
    #[serde(rename = "publicKey")]
    pub public_key: String,
    #[serde(rename = "tokenId")]
    pub token_id: String,
}

/// Delete Personal Access Token
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeletePersonalAccessTokenResponse {
    #[serde(
        rename = "accessToken",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub access_token: Option<String>,
    #[serde(rename = "dateCreated")]
    pub date_created: String,
    #[serde(rename = "credId")]
    pub cred_id: String,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "linkedUserId")]
    pub linked_user_id: String,
    #[serde(rename = "linkedAppId")]
    pub linked_app_id: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "orgId")]
    pub org_id: String,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
    #[serde(rename = "publicKey")]
    pub public_key: String,
    #[serde(rename = "tokenId")]
    pub token_id: String,
}

/// Activate Personal Access Token
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ActivatePersonalAccessTokenResponse {
    #[serde(
        rename = "accessToken",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub access_token: Option<String>,
    #[serde(rename = "dateCreated")]
    pub date_created: String,
    #[serde(rename = "credId")]
    pub cred_id: String,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "linkedUserId")]
    pub linked_user_id: String,
    #[serde(rename = "linkedAppId")]
    pub linked_app_id: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "orgId")]
    pub org_id: String,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
    #[serde(rename = "publicKey")]
    pub public_key: String,
    #[serde(rename = "tokenId")]
    pub token_id: String,
}

/// Deactivate Personal Access Token
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeactivatePersonalAccessTokenResponse {
    #[serde(
        rename = "accessToken",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub access_token: Option<String>,
    #[serde(rename = "dateCreated")]
    pub date_created: String,
    #[serde(rename = "credId")]
    pub cred_id: String,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "linkedUserId")]
    pub linked_user_id: String,
    #[serde(rename = "linkedAppId")]
    pub linked_app_id: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "orgId")]
    pub org_id: String,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
    #[serde(rename = "publicKey")]
    pub public_key: String,
    #[serde(rename = "tokenId")]
    pub token_id: String,
}

/// Create Delegated Recovery Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateDelegatedRecoveryChallengeRequest {
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "credentialId")]
    pub credential_id: String,
}

/// Create Delegated Recovery Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateDelegatedRecoveryChallengeResponse {
    #[serde(rename = "user")]
    pub user: serde_json::Value,
    #[serde(rename = "temporaryAuthenticationToken")]
    pub temporary_authentication_token: String,
    #[serde(rename = "challenge")]
    pub challenge: String,
    #[serde(rename = "rp", default, skip_serializing_if = "Option::is_none")]
    pub rp: Option<serde_json::Value>,
    #[serde(rename = "supportedCredentialKinds")]
    pub supported_credential_kinds: serde_json::Value,
    #[serde(rename = "authenticatorSelection")]
    pub authenticator_selection: serde_json::Value,
    #[serde(rename = "attestation")]
    pub attestation: String,
    #[serde(rename = "pubKeyCredParams")]
    pub pub_key_cred_params: Vec<serde_json::Value>,
    #[serde(rename = "excludeCredentials")]
    pub exclude_credentials: Vec<serde_json::Value>,
    #[serde(rename = "otpUrl")]
    pub otp_url: String,
    #[serde(rename = "allowedRecoveryCredentials")]
    pub allowed_recovery_credentials: Vec<serde_json::Value>,
}

/// Recover User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct RecoverUserRequest {
    #[serde(rename = "recovery")]
    pub recovery: serde_json::Value,
    #[serde(rename = "newCredentials")]
    pub new_credentials: serde_json::Value,
}

/// Recover User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct RecoverUserResponse {
    #[serde(rename = "credential")]
    pub credential: serde_json::Value,
    #[serde(rename = "user")]
    pub user: serde_json::Value,
}

/// Create Recovery Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateRecoveryChallengeRequest {
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "verificationCode")]
    pub verification_code: String,
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(rename = "credentialId")]
    pub credential_id: String,
}

/// Create Recovery Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateRecoveryChallengeResponse {
    #[serde(rename = "user")]
    pub user: serde_json::Value,
    #[serde(rename = "temporaryAuthenticationToken")]
    pub temporary_authentication_token: String,
    #[serde(rename = "challenge")]
    pub challenge: String,
    #[serde(rename = "rp", default, skip_serializing_if = "Option::is_none")]
    pub rp: Option<serde_json::Value>,
    #[serde(rename = "supportedCredentialKinds")]
    pub supported_credential_kinds: serde_json::Value,
    #[serde(rename = "authenticatorSelection")]
    pub authenticator_selection: serde_json::Value,
    #[serde(rename = "attestation")]
    pub attestation: String,
    #[serde(rename = "pubKeyCredParams")]
    pub pub_key_cred_params: Vec<serde_json::Value>,
    #[serde(rename = "excludeCredentials")]
    pub exclude_credentials: Vec<serde_json::Value>,
    #[serde(rename = "otpUrl")]
    pub otp_url: String,
    #[serde(rename = "allowedRecoveryCredentials")]
    pub allowed_recovery_credentials: Vec<serde_json::Value>,
}

/// Send Recovery Code Email
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct SendRecoveryCodeEmailRequest {
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
}

/// Send Recovery Code Email
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct SendRecoveryCodeEmailResponse {
    #[serde(rename = "message")]
    pub message: String,
}

/// Create Delegated Registration Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateDelegatedRegistrationChallengeRequest {
    #[serde(rename = "email")]
    pub email: String,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(
        rename = "externalId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub external_id: Option<String>,
}

/// Create Delegated Registration Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateDelegatedRegistrationChallengeResponse {
    #[serde(rename = "user")]
    pub user: serde_json::Value,
    #[serde(rename = "temporaryAuthenticationToken")]
    pub temporary_authentication_token: String,
    #[serde(rename = "challenge")]
    pub challenge: String,
    #[serde(rename = "rp", default, skip_serializing_if = "Option::is_none")]
    pub rp: Option<serde_json::Value>,
    #[serde(rename = "supportedCredentialKinds")]
    pub supported_credential_kinds: serde_json::Value,
    #[serde(rename = "authenticatorSelection")]
    pub authenticator_selection: serde_json::Value,
    #[serde(rename = "attestation")]
    pub attestation: String,
    #[serde(rename = "pubKeyCredParams")]
    pub pub_key_cred_params: Vec<serde_json::Value>,
    #[serde(rename = "excludeCredentials")]
    pub exclude_credentials: Vec<serde_json::Value>,
    #[serde(rename = "otpUrl")]
    pub otp_url: String,
}

/// Create Registration Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateRegistrationChallengeRequest {
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "registrationCode")]
    pub registration_code: String,
}

/// Create Registration Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateRegistrationChallengeResponse {
    #[serde(rename = "user")]
    pub user: serde_json::Value,
    #[serde(rename = "temporaryAuthenticationToken")]
    pub temporary_authentication_token: String,
    #[serde(rename = "challenge")]
    pub challenge: String,
    #[serde(rename = "rp", default, skip_serializing_if = "Option::is_none")]
    pub rp: Option<serde_json::Value>,
    #[serde(rename = "supportedCredentialKinds")]
    pub supported_credential_kinds: serde_json::Value,
    #[serde(rename = "authenticatorSelection")]
    pub authenticator_selection: serde_json::Value,
    #[serde(rename = "attestation")]
    pub attestation: String,
    #[serde(rename = "pubKeyCredParams")]
    pub pub_key_cred_params: Vec<serde_json::Value>,
    #[serde(rename = "excludeCredentials")]
    pub exclude_credentials: Vec<serde_json::Value>,
    #[serde(rename = "otpUrl")]
    pub otp_url: String,
}

/// Create Social Registration Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateSocialRegistrationChallengeRequest {
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "socialLoginProviderKind")]
    pub social_login_provider_kind: String,
    #[serde(rename = "idToken")]
    pub id_token: String,
}

/// Create Social Registration Challenge
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateSocialRegistrationChallengeResponse {
    #[serde(rename = "user")]
    pub user: serde_json::Value,
    #[serde(rename = "temporaryAuthenticationToken")]
    pub temporary_authentication_token: String,
    #[serde(rename = "challenge")]
    pub challenge: String,
    #[serde(rename = "rp", default, skip_serializing_if = "Option::is_none")]
    pub rp: Option<serde_json::Value>,
    #[serde(rename = "supportedCredentialKinds")]
    pub supported_credential_kinds: serde_json::Value,
    #[serde(rename = "authenticatorSelection")]
    pub authenticator_selection: serde_json::Value,
    #[serde(rename = "attestation")]
    pub attestation: String,
    #[serde(rename = "pubKeyCredParams")]
    pub pub_key_cred_params: Vec<serde_json::Value>,
    #[serde(rename = "excludeCredentials")]
    pub exclude_credentials: Vec<serde_json::Value>,
    #[serde(rename = "otpUrl")]
    pub otp_url: String,
}

/// Complete User Registration
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CompleteUserRegistrationRequest {
    #[serde(rename = "firstFactorCredential")]
    pub first_factor_credential: serde_json::Value,
    #[serde(
        rename = "secondFactorCredential",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub second_factor_credential: Option<serde_json::Value>,
    #[serde(
        rename = "recoveryCredential",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub recovery_credential: Option<crate::types::RecoveryKeyAttestation>,
}

/// Complete User Registration
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CompleteUserRegistrationResponse {
    #[serde(rename = "credential")]
    pub credential: serde_json::Value,
    #[serde(rename = "user")]
    pub user: serde_json::Value,
}

/// Complete End User Registration with Wallets
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CompleteEndUserRegistrationWithWalletsRequest {
    #[serde(rename = "firstFactorCredential")]
    pub first_factor_credential: serde_json::Value,
    #[serde(
        rename = "secondFactorCredential",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub second_factor_credential: Option<serde_json::Value>,
    #[serde(
        rename = "recoveryCredential",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub recovery_credential: Option<crate::types::RecoveryKeyAttestation>,
    #[serde(rename = "wallets")]
    pub wallets: Vec<serde_json::Value>,
}

/// Complete End User Registration with Wallets
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CompleteEndUserRegistrationWithWalletsResponse {
    #[serde(rename = "credential")]
    pub credential: serde_json::Value,
    #[serde(rename = "user")]
    pub user: serde_json::Value,
    #[serde(rename = "authentication")]
    pub authentication: serde_json::Value,
    #[serde(rename = "wallets")]
    pub wallets: Vec<crate::types::Wallet>,
}

/// Resend Registration Code
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ResendRegistrationCodeRequest {
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
}

/// Resend Registration Code
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ResendRegistrationCodeResponse {
    #[serde(rename = "message")]
    pub message: String,
}

/// List Service Accounts
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ListServiceAccountsResponse {
    #[serde(rename = "items")]
    pub items: Vec<serde_json::Value>,
}

/// Create Service Account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateServiceAccountRequest {
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "publicKey")]
    pub public_key: String,
    #[serde(
        rename = "permissionId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub permission_id: Option<String>,
    #[serde(
        rename = "externalId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub external_id: Option<String>,
    #[serde(rename = "daysValid", default, skip_serializing_if = "Option::is_none")]
    pub days_valid: Option<i64>,
}

/// Create Service Account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateServiceAccountResponse {
    #[serde(rename = "userInfo")]
    pub user_info: serde_json::Value,
    #[serde(rename = "accessTokens")]
    pub access_tokens: Vec<crate::types::PersonalAccessToken>,
}

/// Get Service Account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct GetServiceAccountResponse {
    #[serde(rename = "userInfo")]
    pub user_info: serde_json::Value,
    #[serde(rename = "accessTokens")]
    pub access_tokens: Vec<crate::types::PersonalAccessToken>,
}

/// Update Service Account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct UpdateServiceAccountRequest {
    #[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(
        rename = "externalId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub external_id: Option<String>,
}

/// Update Service Account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct UpdateServiceAccountResponse {
    #[serde(rename = "userInfo")]
    pub user_info: serde_json::Value,
    #[serde(rename = "accessTokens")]
    pub access_tokens: Vec<crate::types::PersonalAccessToken>,
}

/// Delete Service Account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeleteServiceAccountResponse {
    #[serde(rename = "userInfo")]
    pub user_info: serde_json::Value,
    #[serde(rename = "accessTokens")]
    pub access_tokens: Vec<crate::types::PersonalAccessToken>,
}

/// Query parameters for the DeleteServiceAccountQuery operation.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeleteServiceAccountQuery {
    #[serde(rename = "force", default, skip_serializing_if = "Option::is_none")]
    pub force: Option<serde_json::Value>,
}

/// Activate Service Account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ActivateServiceAccountResponse {
    #[serde(rename = "userInfo")]
    pub user_info: serde_json::Value,
    #[serde(rename = "accessTokens")]
    pub access_tokens: Vec<crate::types::PersonalAccessToken>,
}

/// Deactivate Service Account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeactivateServiceAccountRequest {
    #[serde(rename = "force", default, skip_serializing_if = "Option::is_none")]
    pub force: Option<bool>,
}

/// Deactivate Service Account
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeactivateServiceAccountResponse {
    #[serde(rename = "userInfo")]
    pub user_info: serde_json::Value,
    #[serde(rename = "accessTokens")]
    pub access_tokens: Vec<crate::types::PersonalAccessToken>,
}

/// Activate User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ActivateUserResponse {
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "userId")]
    pub user_id: String,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "credentialUuid")]
    pub credential_uuid: String,
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(
        rename = "permissions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub permissions: Option<Vec<String>>,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "isServiceAccount")]
    pub is_service_account: bool,
    #[serde(rename = "isRegistered")]
    pub is_registered: bool,
    #[serde(rename = "isSSORequired")]
    pub is_ssorequired: bool,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
}

/// Deactivate User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeactivateUserResponse {
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "userId")]
    pub user_id: String,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "credentialUuid")]
    pub credential_uuid: String,
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(
        rename = "permissions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub permissions: Option<Vec<String>>,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "isServiceAccount")]
    pub is_service_account: bool,
    #[serde(rename = "isRegistered")]
    pub is_registered: bool,
    #[serde(rename = "isSSORequired")]
    pub is_ssorequired: bool,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
}

/// Get User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct GetUserResponse {
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "userId")]
    pub user_id: String,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "credentialUuid")]
    pub credential_uuid: String,
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(
        rename = "permissions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub permissions: Option<Vec<String>>,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "isServiceAccount")]
    pub is_service_account: bool,
    #[serde(rename = "isRegistered")]
    pub is_registered: bool,
    #[serde(rename = "isSSORequired")]
    pub is_ssorequired: bool,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
}

/// Update User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct UpdateUserRequest {
    #[serde(rename = "isSSORequired")]
    pub is_ssorequired: bool,
}

/// Update User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct UpdateUserResponse {
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "userId")]
    pub user_id: String,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "credentialUuid")]
    pub credential_uuid: String,
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(
        rename = "permissions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub permissions: Option<Vec<String>>,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "isServiceAccount")]
    pub is_service_account: bool,
    #[serde(rename = "isRegistered")]
    pub is_registered: bool,
    #[serde(rename = "isSSORequired")]
    pub is_ssorequired: bool,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
}

/// Delete User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct DeleteUserResponse {
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "userId")]
    pub user_id: String,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "credentialUuid")]
    pub credential_uuid: String,
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(
        rename = "permissions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub permissions: Option<Vec<String>>,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "isServiceAccount")]
    pub is_service_account: bool,
    #[serde(rename = "isRegistered")]
    pub is_registered: bool,
    #[serde(rename = "isSSORequired")]
    pub is_ssorequired: bool,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
}

/// List Users
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ListUsersResponse {
    #[serde(rename = "items")]
    pub items: Vec<crate::types::User>,
    #[serde(
        rename = "nextPageToken",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub next_page_token: Option<String>,
}

/// Query parameters for the ListUsersQuery operation.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ListUsersQuery {
    #[serde(rename = "limit", default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(
        rename = "paginationToken",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub pagination_token: Option<String>,
    #[serde(rename = "kind", default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
}

/// Create User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateUserRequest {
    #[serde(rename = "email")]
    pub email: String,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "publicKey", default, skip_serializing_if = "Option::is_none")]
    pub public_key: Option<String>,
    #[serde(
        rename = "externalId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub external_id: Option<String>,
    #[serde(
        rename = "isSSORequired",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub is_ssorequired: Option<bool>,
}

/// Create User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CreateUserResponse {
    #[serde(rename = "username")]
    pub username: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "userId")]
    pub user_id: String,
    #[serde(rename = "kind")]
    pub kind: String,
    #[serde(rename = "credentialUuid")]
    pub credential_uuid: String,
    #[serde(rename = "orgId", default, skip_serializing_if = "Option::is_none")]
    pub org_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(
        rename = "permissions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub permissions: Option<Vec<String>>,
    #[serde(rename = "isActive")]
    pub is_active: bool,
    #[serde(rename = "isServiceAccount")]
    pub is_service_account: bool,
    #[serde(rename = "isRegistered")]
    pub is_registered: bool,
    #[serde(rename = "isSSORequired")]
    pub is_ssorequired: bool,
    #[serde(rename = "permissionAssignments")]
    pub permission_assignments: Vec<serde_json::Value>,
}

/// Invite Tenant User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct InviteTenantUserRequest {
    #[serde(rename = "email")]
    pub email: String,
    #[serde(rename = "kind")]
    pub kind: String,
}

/// Invite Tenant User
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct InviteTenantUserResponse {}