#![allow(clippy::struct_excessive_bools)]
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::Sensitive;
pub(crate) fn skip_empty_list<T>(value: &Option<Vec<T>>) -> bool {
value.as_ref().is_none_or(|list| list.is_empty())
}
pub(crate) fn default_true() -> bool {
true
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AcsEndpoint {
pub binding: SamlBinding,
pub index: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub is_default: Option<bool>,
pub url: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ActorType {
User,
ServiceAccount,
System,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AddMemberRequest {
pub user_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AddServiceAccountMemberRequest {
pub service_account_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct ApiProviderConfig {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub api_url: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AssignRoleToGroupRequest {
pub group_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub inherit: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<Uuid>,
#[serde(default, skip_serializing_if = "skip_empty_list")]
pub tenant_scope: Option<Vec<Uuid>>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AssignRoleToServiceAccountRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub inherit: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<Uuid>,
pub service_account_id: Uuid,
#[serde(default, skip_serializing_if = "skip_empty_list")]
pub tenant_scope: Option<Vec<Uuid>>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AssignRoleToUserRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub inherit: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<Uuid>,
#[serde(default, skip_serializing_if = "skip_empty_list")]
pub tenant_scope: Option<Vec<Uuid>>,
pub user_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum AttestationMode {
#[serde(rename = "none")]
None,
#[serde(rename = "indirect")]
Indirect,
#[serde(rename = "direct_required")]
DirectRequired,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AttributeMapping {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name_format: Option<String>,
pub saml_name: String,
pub source: AttributeSource,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum AttributeSource {
#[serde(rename = "username")]
Username,
#[serde(rename = "email")]
Email,
#[serde(rename = "display_name")]
DisplayName,
#[serde(rename = "given_name")]
GivenName,
#[serde(rename = "family_name")]
FamilyName,
#[serde(rename = "groups")]
Groups,
#[serde(rename = "roles")]
Roles,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AuditLogEntry {
pub action: String,
pub actor_id: Uuid,
pub actor_type: ActorType,
pub id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ip_address: Option<String>,
pub metadata: serde_json::Value,
pub outcome: AuditOutcome,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<Uuid>,
pub tenant_id: Uuid,
pub timestamp: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum AuditOutcome {
Success,
Failure,
Denied,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum AuthnRequestParamsMode {
#[serde(rename = "ignore")]
Ignore,
#[serde(rename = "honour")]
Honour,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BindCertificate {
pub certificate_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CaCertificate {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub chain_pem: Option<String>,
pub created_at: String,
pub fingerprint: String,
pub id: Uuid,
pub key_algorithm: KeyAlgorithm,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub key_custody: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub key_locator: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mtls_trust_anchor: Option<bool>,
pub not_after: String,
pub not_before: String,
pub organization_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub parent_ca_id: Option<Uuid>,
pub public_cert_pem: String,
pub status: CertificateStatus,
pub subject: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tenant_id: Option<Uuid>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Certificate {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bound_service_account_id: Option<Uuid>,
pub cert_type: CertificateType,
pub created_at: String,
pub fingerprint: String,
pub id: Uuid,
pub issuer_ca_id: Uuid,
pub key_algorithm: KeyAlgorithm,
pub metadata: serde_json::Value,
pub not_after: String,
pub not_before: String,
pub public_cert_pem: String,
pub status: CertificateStatus,
pub subject: String,
pub tenant_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub user_id: Option<Uuid>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CertificatePolicy {
pub default_cert_validity_days: i32,
pub max_cert_validity_days: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub server_cert_allowed_names: Option<Vec<String>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum CertificateStatus {
Active,
Revoked,
Expired,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum CertificateType {
User,
Service,
Device,
Server,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum CertificationLevel {
L1,
L1Plus,
L2,
L2Plus,
L3,
L3Plus,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum CibaDeliveryMode {
#[serde(rename = "poll")]
Poll,
#[serde(rename = "ping")]
Ping,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum CibaRequestSigningAlg {
PS256,
ES256,
EdDSA,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct CimdPolicy {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allow_http: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub confidential_only: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_cache_secs: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_metadata_bytes: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub min_cache_secs: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub restrict_same_domain: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub trusted_client_id_domains: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub trusted_redirect_domains: Option<Vec<String>>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ClientAuthMethod {
#[serde(rename = "client_secret_post")]
ClientSecretPost,
#[serde(rename = "client_secret_basic")]
ClientSecretBasic,
#[serde(rename = "tls_client_auth")]
TlsClientAuth,
#[serde(rename = "self_signed_tls_client_auth")]
SelfSignedTlsClientAuth,
#[serde(rename = "private_key_jwt")]
PrivateKeyJwt,
#[serde(rename = "none")]
None,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ClientProfile {
#[serde(rename = "standard")]
Standard,
#[serde(rename = "fapi2")]
Fapi2,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ComplianceReportEntry {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub aaguid: Option<Uuid>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub authenticator_name: Option<String>,
pub compliant: bool,
pub credential_id: Uuid,
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
pub user_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConsentView {
pub accepted_at: String,
pub consent_type: String,
pub version: String,
pub withdrawable: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateCaCertificateRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub intermediate_subject: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub intermediate_validity_days: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub issue_from_root: Option<bool>,
pub key_algorithm: KeyAlgorithm,
pub subject: String,
pub validity_days: i32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateCertificateRequest {
pub cert_type: CertificateType,
pub issuer_ca_id: Uuid,
pub key_algorithm: KeyAlgorithm,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<serde_json::Value>,
pub subject: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub subject_alt_names: Option<Vec<SubjectAltName>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
pub validity_days: i32,
}
#[derive(Debug, Clone)]
pub struct CreateFederationConfigRequest {
pub allow_sha1_signatures: Option<bool>,
pub allow_tenant_inheritance: Option<bool>,
pub allowed_algorithms: Option<Vec<String>>,
pub allowed_issuer_tenants: Option<Vec<String>>,
pub apple_key_id: Option<String>,
pub apple_team_id: Option<String>,
pub attribute_map: Option<serde_json::Value>,
pub authorization_endpoint: Option<String>,
pub button_icon: Option<String>,
pub client_id: String,
pub client_secret: Sensitive<String>,
pub idp_metadata_signing_cert_pem: Option<String>,
pub idp_signing_cert_pem: Option<String>,
pub metadata_url: Option<String>,
pub native_login: Option<NativeLoginTrustRequest>,
pub protocol: String,
pub provider: String,
pub provider_kind: Option<String>,
pub provider_slug: Option<String>,
pub require_pkce: Option<bool>,
pub scopes: Option<Vec<String>>,
pub token_endpoint: Option<String>,
pub token_exchange: Option<TokenExchangeTrustRequest>,
pub userinfo_endpoint: Option<String>,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct CreateFederationConfigRequestWire {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) allow_sha1_signatures: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) allow_tenant_inheritance: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) allowed_algorithms: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) allowed_issuer_tenants: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) apple_key_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) apple_team_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) attribute_map: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) authorization_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) button_icon: Option<String>,
pub(crate) client_id: String,
pub(crate) client_secret: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) idp_metadata_signing_cert_pem: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) idp_signing_cert_pem: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) metadata_url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) native_login: Option<NativeLoginTrustRequest>,
pub(crate) protocol: String,
pub(crate) provider: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) provider_kind: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) provider_slug: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) require_pkce: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) scopes: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) token_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) token_exchange: Option<TokenExchangeTrustRequest>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) userinfo_endpoint: Option<String>,
}
impl From<&CreateFederationConfigRequest> for CreateFederationConfigRequestWire {
fn from(v: &CreateFederationConfigRequest) -> Self {
Self {
allow_sha1_signatures: v.allow_sha1_signatures,
allow_tenant_inheritance: v.allow_tenant_inheritance,
allowed_algorithms: v.allowed_algorithms.clone(),
allowed_issuer_tenants: v.allowed_issuer_tenants.clone(),
apple_key_id: v.apple_key_id.clone(),
apple_team_id: v.apple_team_id.clone(),
attribute_map: v.attribute_map.clone(),
authorization_endpoint: v.authorization_endpoint.clone(),
button_icon: v.button_icon.clone(),
client_id: v.client_id.clone(),
client_secret: crate::management::error::expose_for_wire(&v.client_secret),
idp_metadata_signing_cert_pem: v.idp_metadata_signing_cert_pem.clone(),
idp_signing_cert_pem: v.idp_signing_cert_pem.clone(),
metadata_url: v.metadata_url.clone(),
native_login: v.native_login.clone(),
protocol: v.protocol.clone(),
provider: v.provider.clone(),
provider_kind: v.provider_kind.clone(),
provider_slug: v.provider_slug.clone(),
require_pkce: v.require_pkce,
scopes: v.scopes.clone(),
token_endpoint: v.token_endpoint.clone(),
token_exchange: v.token_exchange.clone(),
userinfo_endpoint: v.userinfo_endpoint.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateGroupRequest {
pub description: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<serde_json::Value>,
pub name: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateIntermediateCaRequest {
pub key_algorithm: KeyAlgorithm,
pub parent_ca_id: Uuid,
pub subject: String,
pub validity_days: i32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateNetworkReplyProfileRequest {
pub profile: NetworkReplyProfileInput,
pub segment_id: Uuid,
pub segment_version: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateNetworkSegmentRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub filter_ids: Option<Vec<String>>,
pub kind: NetworkSegmentKind,
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rank: Option<i32>,
pub site_key: String,
pub vlan_id: i32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateNotificationRuleRequest {
pub description: String,
pub events: Vec<NotificationEventType>,
pub name: String,
pub recipient_emails: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub window_minutes: Option<i32>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateOAuth2ClientRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allowed_resources: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub authn_request_params: Option<AuthnRequestParamsMode>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_authentication_request_signing_alg: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_client_notification_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_logout_uri: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_token_delivery_mode: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_user_code_parameter: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub browser_sso: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub default_idp: Option<Uuid>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dpop_bound_access_tokens: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dpop_require_nonce: Option<bool>,
pub grant_types: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub jwks: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub jwks_uri: Option<String>,
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub post_logout_redirect_uris: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub profile: Option<ClientProfile>,
pub redirect_uris: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub require_par: Option<bool>,
pub scopes: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub self_signed_tls_client_auth_thumbprints: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_client_auth_san_dns: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_client_auth_san_uri: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_client_auth_subject_dn: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_client_certificate_bound_access_tokens: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub token_endpoint_auth_method: Option<ClientAuthMethod>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreatePermissionRequest {
pub action: String,
pub description: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreatePgpKeyRequest {
pub algorithm: PgpKeyAlgorithm,
pub email: String,
pub name: String,
pub purpose: PgpKeyPurpose,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateReactorRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
pub events: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub failure_policy: Option<FailurePolicy>,
pub mode: ReactorMode,
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub priority: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub timeout_ms: Option<i32>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateRegistrationTokenRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub expires_in_hours: Option<i32>,
pub name: String,
}
#[derive(Debug, Clone)]
pub struct CreateRegistrationTokenResponse {
pub initial_access_token: Sensitive<String>,
pub token: RegistrationTokenResponse,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct CreateRegistrationTokenResponseWire {
pub(crate) initial_access_token: String,
pub(crate) token: RegistrationTokenResponse,
}
impl From<CreateRegistrationTokenResponseWire> for CreateRegistrationTokenResponse {
fn from(w: CreateRegistrationTokenResponseWire) -> Self {
Self {
initial_access_token: crate::management::error::wrap_from_wire(w.initial_access_token),
token: w.token,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateResourceRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<serde_json::Value>,
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub parent_id: Option<Uuid>,
pub resource_type: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateRoleRequest {
pub description: String,
pub is_global: bool,
pub name: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateScimTokenRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub expires_in_days: Option<i64>,
pub name: String,
pub user_id: Uuid,
}
#[derive(Debug, Clone)]
pub struct CreateScimTokenResponse {
pub created_at: String,
pub created_by: Uuid,
pub expires_at: String,
pub id: Uuid,
pub last_used_at: Option<String>,
pub name: String,
pub provisioning_token: Sensitive<String>,
pub revoked_at: Option<String>,
pub status: ScimTokenStatus,
pub tenant_id: Uuid,
pub user_id: Uuid,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct CreateScimTokenResponseWire {
pub(crate) created_at: String,
pub(crate) created_by: Uuid,
pub(crate) expires_at: String,
pub(crate) id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) last_used_at: Option<String>,
pub(crate) name: String,
pub(crate) provisioning_token: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) revoked_at: Option<String>,
pub(crate) status: ScimTokenStatus,
pub(crate) tenant_id: Uuid,
pub(crate) user_id: Uuid,
}
impl From<CreateScimTokenResponseWire> for CreateScimTokenResponse {
fn from(w: CreateScimTokenResponseWire) -> Self {
Self {
created_at: w.created_at,
created_by: w.created_by,
expires_at: w.expires_at,
id: w.id,
last_used_at: w.last_used_at,
name: w.name,
provisioning_token: crate::management::error::wrap_from_wire(w.provisioning_token),
revoked_at: w.revoked_at,
status: w.status,
tenant_id: w.tenant_id,
user_id: w.user_id,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateScopeRequest {
pub description: String,
pub name: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateServiceAccountRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub name: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreateTenantRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<serde_json::Value>,
pub name: String,
pub slug: String,
}
#[derive(Debug, Clone)]
pub struct CreateUserRequest {
pub email: String,
pub metadata: Option<serde_json::Value>,
pub opaque: Option<OpaqueEnrollment>,
pub password: Sensitive<String>,
pub username: String,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct CreateUserRequestWire {
pub(crate) email: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) metadata: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) opaque: Option<OpaqueEnrollment>,
pub(crate) password: String,
pub(crate) username: String,
}
impl From<&CreateUserRequest> for CreateUserRequestWire {
fn from(v: &CreateUserRequest) -> Self {
Self {
email: v.email.clone(),
metadata: v.metadata.clone(),
opaque: v.opaque.clone(),
password: crate::management::error::expose_for_wire(&v.password),
username: v.username.clone(),
}
}
}
#[derive(Debug, Clone)]
pub struct CreateWebhookRequest {
pub events: Vec<String>,
pub retry_policy: Option<RetryPolicy>,
pub secret: Sensitive<String>,
pub url: String,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct CreateWebhookRequestWire {
pub(crate) events: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) retry_policy: Option<RetryPolicy>,
pub(crate) secret: String,
pub(crate) url: String,
}
impl From<&CreateWebhookRequest> for CreateWebhookRequestWire {
fn from(v: &CreateWebhookRequest) -> Self {
Self {
events: v.events.clone(),
retry_policy: v.retry_policy.clone(),
secret: crate::management::error::expose_for_wire(&v.secret),
url: v.url.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum DeprovisionPolicy {
#[serde(rename = "deactivate")]
Deactivate,
#[serde(rename = "delete")]
Delete,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DirectoryConfig {
pub base_dn: String,
pub bind_dn: String,
pub created_at: String,
pub enabled: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub group_base_dn: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub group_filter: Option<String>,
pub group_mappings: Vec<GroupMapping>,
pub group_member_attribute: String,
pub group_nesting_depth: i32,
pub id: Uuid,
pub jit_provisioning: bool,
pub kind: DirectoryKind,
pub start_tls: bool,
pub sync_interval_secs: i64,
pub tenant_id: Uuid,
pub trust_anchors_pem: Vec<String>,
pub updated_at: String,
pub url: String,
pub user_attribute_map: UserAttributeMap,
pub user_filter: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum DirectoryKind {
#[serde(rename = "open_ldap")]
OpenLdap,
#[serde(rename = "active_directory")]
ActiveDirectory,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DirectoryLinkResult {
pub certificates_revoked: i64,
pub directory_external_id: String,
pub user_id: Uuid,
pub was_already_linked: bool,
pub webauthn_credentials_deleted: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DirectorySyncStatus {
pub full_required: bool,
pub has_watermark: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_attempt_at: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_full_run_at: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_result: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EmailConfig {
pub created_at: String,
pub enabled: bool,
pub from_email: String,
pub from_name: String,
pub id: Uuid,
pub provider: ProviderConfig,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reply_to: Option<String>,
pub scope: SettingsScope,
pub scope_id: Uuid,
pub updated_at: String,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct EmailConfigOverride {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub from_email: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub from_name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provider: Option<ProviderConfig>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reply_to: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EmailTestResult {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message_id: Option<String>,
pub provider: String,
pub to: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EmailVerificationPolicy {
pub email_verification_grace_period_hours: i32,
pub email_verification_required: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EncryptRequest {
pub data_base64: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EncryptedExport {
pub ciphertext_armored: String,
pub recipient_key_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum FailurePolicy {
#[serde(rename = "fail_closed")]
FailClosed,
#[serde(rename = "fail_open")]
FailOpen,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FederationConfigResponse {
#[serde(default)]
pub allow_sha1_signatures: bool,
pub allow_tenant_inheritance: bool,
pub allowed_algorithms: Vec<String>,
pub allowed_issuer_tenants: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub apple_key_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub apple_team_id: Option<String>,
pub attribute_map: serde_json::Value,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub authorization_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub button_icon: Option<String>,
pub client_id: String,
pub created_at: String,
pub effective_scopes: Vec<String>,
pub enabled: bool,
pub has_bundled_mark: bool,
pub id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub idp_metadata_signing_cert_pem: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata_url: Option<String>,
pub mints_client_secret: bool,
pub native_login: NativeLoginTrustResponse,
pub pkce_required: bool,
pub protocol: String,
pub provider: String,
pub provider_kind: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provider_slug: Option<String>,
pub scopes: Vec<String>,
pub tenant_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub token_endpoint: Option<String>,
pub token_exchange: TokenExchangeTrustResponse,
pub updated_at: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub userinfo_endpoint: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FederationLinkResponse {
pub created_at: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub external_email: Option<String>,
pub external_subject: String,
pub federation_config_id: Uuid,
pub id: Uuid,
pub tenant_id: Uuid,
pub updated_at: String,
pub user_id: Uuid,
}
#[derive(Debug, Clone)]
pub struct GeneratedCaCertificate {
pub chain_pem: Option<String>,
pub created_at: String,
pub fingerprint: String,
pub id: Uuid,
pub key_algorithm: KeyAlgorithm,
pub key_custody: Option<String>,
pub key_locator: Option<String>,
pub mtls_trust_anchor: Option<bool>,
pub not_after: String,
pub not_before: String,
pub organization_id: Uuid,
pub parent_ca_id: Option<Uuid>,
pub private_key_pem: Option<Sensitive<String>>,
pub public_cert_pem: String,
pub status: CertificateStatus,
pub subject: String,
pub tenant_id: Option<Uuid>,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct GeneratedCaCertificateWire {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) chain_pem: Option<String>,
pub(crate) created_at: String,
pub(crate) fingerprint: String,
pub(crate) id: Uuid,
pub(crate) key_algorithm: KeyAlgorithm,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) key_custody: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) key_locator: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) mtls_trust_anchor: Option<bool>,
pub(crate) not_after: String,
pub(crate) not_before: String,
pub(crate) organization_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) parent_ca_id: Option<Uuid>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) private_key_pem: Option<String>,
pub(crate) public_cert_pem: String,
pub(crate) status: CertificateStatus,
pub(crate) subject: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) tenant_id: Option<Uuid>,
}
impl From<GeneratedCaCertificateWire> for GeneratedCaCertificate {
fn from(w: GeneratedCaCertificateWire) -> Self {
Self {
chain_pem: w.chain_pem,
created_at: w.created_at,
fingerprint: w.fingerprint,
id: w.id,
key_algorithm: w.key_algorithm,
key_custody: w.key_custody,
key_locator: w.key_locator,
mtls_trust_anchor: w.mtls_trust_anchor,
not_after: w.not_after,
not_before: w.not_before,
organization_id: w.organization_id,
parent_ca_id: w.parent_ca_id,
private_key_pem: w
.private_key_pem
.map(crate::management::error::wrap_from_wire),
public_cert_pem: w.public_cert_pem,
status: w.status,
subject: w.subject,
tenant_id: w.tenant_id,
}
}
}
#[derive(Debug, Clone)]
pub struct GeneratedCertificate {
pub cert_type: CertificateType,
pub chain_pem: Option<String>,
pub created_at: String,
pub fingerprint: String,
pub id: Uuid,
pub issuer_ca_id: Uuid,
pub key_algorithm: KeyAlgorithm,
pub metadata: serde_json::Value,
pub not_after: String,
pub not_before: String,
pub private_key_pem: Sensitive<String>,
pub public_cert_pem: String,
pub status: CertificateStatus,
pub subject: String,
pub tenant_id: Uuid,
pub user_id: Option<Uuid>,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct GeneratedCertificateWire {
pub(crate) cert_type: CertificateType,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) chain_pem: Option<String>,
pub(crate) created_at: String,
pub(crate) fingerprint: String,
pub(crate) id: Uuid,
pub(crate) issuer_ca_id: Uuid,
pub(crate) key_algorithm: KeyAlgorithm,
pub(crate) metadata: serde_json::Value,
pub(crate) not_after: String,
pub(crate) not_before: String,
pub(crate) private_key_pem: String,
pub(crate) public_cert_pem: String,
pub(crate) status: CertificateStatus,
pub(crate) subject: String,
pub(crate) tenant_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) user_id: Option<Uuid>,
}
impl From<GeneratedCertificateWire> for GeneratedCertificate {
fn from(w: GeneratedCertificateWire) -> Self {
Self {
cert_type: w.cert_type,
chain_pem: w.chain_pem,
created_at: w.created_at,
fingerprint: w.fingerprint,
id: w.id,
issuer_ca_id: w.issuer_ca_id,
key_algorithm: w.key_algorithm,
metadata: w.metadata,
not_after: w.not_after,
not_before: w.not_before,
private_key_pem: crate::management::error::wrap_from_wire(w.private_key_pem),
public_cert_pem: w.public_cert_pem,
status: w.status,
subject: w.subject,
tenant_id: w.tenant_id,
user_id: w.user_id,
}
}
}
#[derive(Debug, Clone)]
pub struct GeneratedPgpKey {
pub algorithm: PgpKeyAlgorithm,
pub created_at: String,
pub fingerprint: String,
pub id: Uuid,
pub name: String,
pub private_key_armored: Option<Sensitive<String>>,
pub public_key_armored: String,
pub purpose: PgpKeyPurpose,
pub status: PgpKeyStatus,
pub tenant_id: Uuid,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct GeneratedPgpKeyWire {
pub(crate) algorithm: PgpKeyAlgorithm,
pub(crate) created_at: String,
pub(crate) fingerprint: String,
pub(crate) id: Uuid,
pub(crate) name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) private_key_armored: Option<String>,
pub(crate) public_key_armored: String,
pub(crate) purpose: PgpKeyPurpose,
pub(crate) status: PgpKeyStatus,
pub(crate) tenant_id: Uuid,
}
impl From<GeneratedPgpKeyWire> for GeneratedPgpKey {
fn from(w: GeneratedPgpKeyWire) -> Self {
Self {
algorithm: w.algorithm,
created_at: w.created_at,
fingerprint: w.fingerprint,
id: w.id,
name: w.name,
private_key_armored: w
.private_key_armored
.map(crate::management::error::wrap_from_wire),
public_key_armored: w.public_key_armored,
purpose: w.purpose,
status: w.status,
tenant_id: w.tenant_id,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GrantPermissionRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub effect: Option<PermissionEffect>,
pub permission_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scope_ids: Option<Vec<Uuid>>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GrantScopeConsent {
pub client_id: String,
pub scopes: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GrantedScope {
pub id: Uuid,
pub name: String,
pub resource_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Group {
pub created_at: String,
pub description: String,
pub id: Uuid,
pub metadata: serde_json::Value,
pub name: String,
pub tenant_id: Uuid,
pub updated_at: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GroupMapping {
pub directory_group_dn: String,
pub group_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HealthResponse {
pub profile: String,
pub status: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub unavailable: Option<Vec<String>>,
}
#[derive(Debug, Clone)]
pub struct ImportCaCertificateRequest {
pub private_key_pem: Option<Sensitive<String>>,
pub public_cert_pem: String,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct ImportCaCertificateRequestWire {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) private_key_pem: Option<String>,
pub(crate) public_cert_pem: String,
}
impl From<&ImportCaCertificateRequest> for ImportCaCertificateRequestWire {
fn from(v: &ImportCaCertificateRequest) -> Self {
Self {
private_key_pem: v
.private_key_pem
.as_ref()
.map(crate::management::error::expose_for_wire),
public_cert_pem: v.public_cert_pem.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IssueSamlIdpCredential {
pub issuer_ca_id: Uuid,
pub slot: SamlIdpSlot,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub validity_days: Option<i64>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum KeyAlgorithm {
Rsa4096,
Ed25519,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LinkDirectoryAccount {
pub user_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LockoutPolicy {
pub lockout_backoff_multiplier: f64,
pub lockout_duration_secs: i64,
pub max_failed_login_attempts: i32,
pub max_lockout_duration_secs: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ManagedBy {
#[serde(rename = "admin")]
Admin,
#[serde(rename = "dcr")]
Dcr,
#[serde(rename = "cimd")]
Cimd,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "outcome")]
#[non_exhaustive]
pub enum MdsRefreshOutcome {
#[serde(rename = "initial")]
Initial {
entry_count: i64,
no: i64,
},
#[serde(rename = "replaced")]
Replaced {
entry_count: i64,
no: i64,
},
#[serde(rename = "no_op_refresh")]
NoOpRefresh {
no: i64,
},
#[serde(rename = "rollback_rejected")]
RollbackRejected {
attempted_no: i64,
stored_no: i64,
},
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MdsStatusResponse {
pub entry_count: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_refreshed_at: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub next_update: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub no: Option<i64>,
pub stale: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MfaMethodResponse {
pub created_at: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_used_at: Option<String>,
pub method_id: String,
pub method_type: MfaMethodType,
pub name: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum MfaMethodType {
Totp,
Passkey,
SecurityKey,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MfaPolicy {
pub mfa_challenge_lifetime_secs: i64,
pub mfa_enforced: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MigrateCustodyResponse {
pub ca_certificate_id: Uuid,
pub key_custody: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub key_locator: Option<String>,
pub previous_custody: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MtlsTrustAnchorResponse {
pub ca_certificate_id: Uuid,
pub message: String,
pub mtls_trust_anchor: bool,
pub restart_required: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub trusted_anchors: Option<i64>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum NameIdFormat {
#[serde(rename = "persistent")]
Persistent,
#[serde(rename = "email_address")]
EmailAddress,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct NativeLoginTrustRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub client_ids: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_token_age_secs: Option<i64>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NativeLoginTrustResponse {
pub client_ids: Vec<String>,
pub enabled: bool,
pub max_token_age_secs: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NetworkPolicyResponse {
pub session_timeout_max_secs: i32,
pub tenant_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub updated_by: Option<Uuid>,
pub version: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NetworkReplyProfile {
pub created_at: String,
pub created_by: Uuid,
pub dictionary: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub filter_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub idle_timeout_secs: Option<i32>,
pub segment_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub service_type: Option<RadiusServiceType>,
pub session_timeout_clamped: bool,
pub session_timeout_secs: i32,
pub tenant_id: Uuid,
pub termination_action: RadiusTerminationAction,
pub updated_at: String,
pub updated_by: Uuid,
pub version: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NetworkReplyProfileInput {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dictionary: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub filter_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub idle_timeout_secs: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub service_type: Option<RadiusServiceType>,
pub session_timeout_secs: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub termination_action: Option<RadiusTerminationAction>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum NetworkSegmentKind {
#[serde(rename = "access")]
Access,
#[serde(rename = "quarantine")]
Quarantine,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NetworkSegmentResponse {
pub created_at: String,
pub created_by: Uuid,
pub enabled: bool,
pub filter_ids: Vec<String>,
pub id: Uuid,
pub kind: NetworkSegmentKind,
pub name: String,
pub path: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rank: Option<i32>,
pub site_key: String,
pub tenant_id: Uuid,
pub updated_at: String,
pub updated_by: Uuid,
pub version: i64,
pub vlan_id: i32,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum NotificationEventType {
#[serde(rename = "login_failure")]
LoginFailure,
#[serde(rename = "account_locked")]
AccountLocked,
#[serde(rename = "mfa_enrollment_changed")]
MfaEnrollmentChanged,
#[serde(rename = "password_changed")]
PasswordChanged,
#[serde(rename = "password_reset_requested")]
PasswordResetRequested,
#[serde(rename = "role_assigned")]
RoleAssigned,
#[serde(rename = "role_unassigned")]
RoleUnassigned,
#[serde(rename = "permission_granted")]
PermissionGranted,
#[serde(rename = "permission_revoked")]
PermissionRevoked,
#[serde(rename = "certificate_issued")]
CertificateIssued,
#[serde(rename = "certificate_revoked")]
CertificateRevoked,
#[serde(rename = "ca_certificate_revoked")]
CaCertificateRevoked,
#[serde(rename = "user_created")]
UserCreated,
#[serde(rename = "user_deleted")]
UserDeleted,
#[serde(rename = "user_updated")]
UserUpdated,
#[serde(rename = "service_account_created")]
ServiceAccountCreated,
#[serde(rename = "service_account_deleted")]
ServiceAccountDeleted,
#[serde(rename = "scim_delivery_failed")]
ScimDeliveryFailed,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NotificationPolicy {
pub admin_notifications_enabled: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NotificationRuleResponse {
pub created_at: String,
pub description: String,
pub enabled: bool,
pub events: Vec<NotificationEventType>,
pub id: Uuid,
pub name: String,
pub recipient_emails: Vec<String>,
pub tenant_id: Uuid,
pub updated_at: String,
pub window_minutes: i32,
}
#[derive(Debug, Clone)]
pub struct OAuth2ClientCreatedResponse {
pub client_id: String,
pub client_secret: Option<Sensitive<String>>,
pub created_at: String,
pub grant_types: Vec<String>,
pub id: Uuid,
pub name: String,
pub redirect_uris: Vec<String>,
pub scopes: Vec<String>,
pub tenant_id: Uuid,
pub updated_at: String,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct OAuth2ClientCreatedResponseWire {
pub(crate) client_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) client_secret: Option<String>,
pub(crate) created_at: String,
pub(crate) grant_types: Vec<String>,
pub(crate) id: Uuid,
pub(crate) name: String,
pub(crate) redirect_uris: Vec<String>,
pub(crate) scopes: Vec<String>,
pub(crate) tenant_id: Uuid,
pub(crate) updated_at: String,
}
impl From<OAuth2ClientCreatedResponseWire> for OAuth2ClientCreatedResponse {
fn from(w: OAuth2ClientCreatedResponseWire) -> Self {
Self {
client_id: w.client_id,
client_secret: w
.client_secret
.map(crate::management::error::wrap_from_wire),
created_at: w.created_at,
grant_types: w.grant_types,
id: w.id,
name: w.name,
redirect_uris: w.redirect_uris,
scopes: w.scopes,
tenant_id: w.tenant_id,
updated_at: w.updated_at,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OAuth2ClientResponse {
pub allowed_resources: Vec<String>,
pub authn_request_params: AuthnRequestParamsMode,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_authentication_request_signing_alg: Option<CibaRequestSigningAlg>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_client_notification_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_token_delivery_mode: Option<CibaDeliveryMode>,
pub browser_sso: bool,
pub client_id: String,
pub created_at: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub default_idp: Option<Uuid>,
pub dpop_bound_access_tokens: bool,
pub dpop_require_nonce: bool,
pub grant_types: Vec<String>,
pub id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub jwks: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub jwks_uri: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_authorized_at: Option<String>,
pub managed_by: ManagedBy,
pub name: String,
pub profile: ClientProfile,
pub redirect_uris: Vec<String>,
pub require_par: bool,
pub scopes: Vec<String>,
pub self_signed_tls_client_auth_thumbprints: Vec<String>,
pub tenant_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_client_auth_san_dns: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_client_auth_san_uri: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_client_auth_subject_dn: Option<String>,
pub tls_client_certificate_bound_access_tokens: bool,
pub token_endpoint_auth_method: ClientAuthMethod,
pub updated_at: String,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct OAuth2Policy {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub refresh_reuse_response: Option<RefreshReuseResponse>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OidcAuthorizeRequest {
pub config_id: Uuid,
pub nonce: String,
pub redirect_uri: String,
pub state: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OidcAuthorizeResponse {
pub url: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OidcCallbackRequest {
pub code: String,
pub config_id: Uuid,
pub nonce: String,
pub redirect_uri: String,
pub state: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OidcCallbackResponse {
pub federation_link_id: Uuid,
pub newly_provisioned: bool,
pub user_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OidcPolicy {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cimd: Option<CimdPolicy>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_allowed_redirect_hosts: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_allowed_scopes: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_max_clients: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_unused_client_ttl_days: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub default_locale: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dynamic_registration: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub external_client_allowed_resources: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub saml_idp_enabled: Option<bool>,
pub sensitive_scopes_enabled: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ssf_enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ssf_inactive_reason: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OpaqueEnrollment {
pub opaque_session: String,
pub registration_record: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OpaquePolicy {
pub opaque_ksf: String,
pub opaque_mode: String,
pub opaque_suite: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Organization {
pub created_at: String,
pub id: Uuid,
pub metadata: serde_json::Value,
pub name: String,
pub slug: String,
pub updated_at: String,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct ParseSamlSpMetadata {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata_url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata_xml: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PasswordPolicy {
pub hibp_check_enabled: bool,
pub min_length: i32,
pub password_history_count: i32,
pub require_digits: bool,
pub require_lowercase: bool,
pub require_symbols: bool,
pub require_uppercase: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Permission {
pub action: String,
pub created_at: String,
pub description: String,
pub id: Uuid,
pub tenant_id: Uuid,
pub updated_at: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum PermissionEffect {
#[serde(rename = "allow")]
Allow,
#[serde(rename = "deny")]
Deny,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PgpKey {
pub algorithm: PgpKeyAlgorithm,
pub created_at: String,
pub fingerprint: String,
pub id: Uuid,
pub name: String,
pub public_key_armored: String,
pub purpose: PgpKeyPurpose,
pub status: PgpKeyStatus,
pub tenant_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum PgpKeyAlgorithm {
Rsa4096,
Ed25519,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum PgpKeyPurpose {
AuditSigning,
Export,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum PgpKeyStatus {
Active,
Revoked,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PolicyResponse {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allowed_aaguids: Option<Vec<Uuid>>,
pub block_revoked_status: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub blocked_aaguids: Option<Vec<Uuid>>,
pub effective_unknown_aaguid: UnknownAaguidAction,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub min_certification: Option<CertificationLevel>,
pub mode: AttestationMode,
pub require_fido_certified: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub unknown_aaguid: Option<UnknownAaguidAction>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PrivacyPolicy {
pub deletion_grace_period_days: i32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind")]
#[non_exhaustive]
pub enum ProviderConfig {
#[serde(rename = "smtp")]
Smtp(SmtpConfig),
#[serde(rename = "send_grid")]
SendGrid(ApiProviderConfig),
#[serde(rename = "postmark")]
Postmark(ApiProviderConfig),
#[serde(rename = "resend")]
Resend(ApiProviderConfig),
#[serde(rename = "brevo")]
Brevo(ApiProviderConfig),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum RadiusServiceType {
#[serde(rename = "framed_user")]
FramedUser,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum RadiusTerminationAction {
#[serde(rename = "default")]
Default,
#[serde(rename = "radius_request")]
RadiusRequest,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReactorEventDescriptor {
pub default_failure_policy: FailurePolicy,
pub description: String,
pub interceptable: bool,
pub mutable: bool,
pub mutable_fields: Vec<String>,
pub name: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ReactorMode {
#[serde(rename = "intercept")]
Intercept,
#[serde(rename = "listen")]
Listen,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReactorResponse {
pub created_at: String,
pub description: String,
pub enabled: bool,
pub events: Vec<String>,
pub failure_policy: FailurePolicy,
pub id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_seen_at: Option<String>,
pub mode: ReactorMode,
pub name: String,
pub priority: i32,
pub recent_timeout_count: i32,
pub recent_veto_count: i32,
pub tenant_id: Uuid,
pub timeout_ms: i32,
pub updated_at: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReadyResponse {
pub database: String,
pub status: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum RefreshReuseResponse {
#[serde(rename = "revoke_session")]
RevokeSession,
#[serde(rename = "refuse")]
Refuse,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RegistrationTokenResponse {
pub created_at: String,
pub created_by: Uuid,
pub expires_at: String,
pub id: Uuid,
pub name: String,
pub tenant_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub used_at: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub used_by_client_id: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReplaceNetworkPolicyRequest {
pub session_timeout_max_secs: i32,
pub version: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReplaceNetworkReplyProfileRequest {
pub profile: NetworkReplyProfileInput,
pub segment_version: i64,
pub version: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReplaceNetworkSegmentRequest {
pub enabled: bool,
pub filter_ids: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rank: Option<i32>,
pub version: i64,
pub vlan_id: i32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ResolvedPermissionGrant {
pub effect: PermissionEffect,
pub permission: Permission,
pub scope_ids: Vec<Uuid>,
pub scopes: Vec<GrantedScope>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Resource {
pub created_at: String,
pub id: Uuid,
pub metadata: serde_json::Value,
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub parent_id: Option<Uuid>,
pub resource_type: String,
pub tenant_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub uma_registered_by: Option<String>,
pub updated_at: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RetryPolicy {
pub backoff_multiplier: f64,
pub initial_delay_secs: i64,
pub max_retries: i32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Role {
pub created_at: String,
pub description: String,
pub id: Uuid,
pub is_global: bool,
pub name: String,
pub tenant_id: Uuid,
pub updated_at: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RoleAssignment {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub inherit: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<Uuid>,
pub role: Role,
#[serde(default, skip_serializing_if = "skip_empty_list")]
pub tenant_scope: Option<Vec<Uuid>>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RoleGroupAssignment {
pub group: Group,
#[serde(default = "default_true")]
pub inherit: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<Uuid>,
#[serde(default, skip_serializing_if = "skip_empty_list")]
pub tenant_scope: Option<Vec<Uuid>>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RoleServiceAccountAssignment {
#[serde(default = "default_true")]
pub inherit: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<Uuid>,
pub service_account: ServiceAccountResponse,
#[serde(default, skip_serializing_if = "skip_empty_list")]
pub tenant_scope: Option<Vec<Uuid>>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RoleUserAssignment {
#[serde(default = "default_true")]
pub inherit: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<Uuid>,
#[serde(default, skip_serializing_if = "skip_empty_list")]
pub tenant_scope: Option<Vec<Uuid>>,
pub user: UserResponse,
}
#[derive(Debug, Clone)]
pub struct RotateSecretResponse {
pub client_secret: Sensitive<String>,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct RotateSecretResponseWire {
pub(crate) client_secret: String,
}
impl From<RotateSecretResponseWire> for RotateSecretResponse {
fn from(w: RotateSecretResponseWire) -> Self {
Self {
client_secret: crate::management::error::wrap_from_wire(w.client_secret),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SamlBinding {
#[serde(rename = "http_post")]
HttpPost,
#[serde(rename = "http_redirect")]
HttpRedirect,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SamlIdpCredential {
pub certificate_pem: String,
pub created_at: String,
pub fingerprint: String,
pub id: Uuid,
pub issuer_ca_id: Uuid,
pub not_after: String,
pub not_before: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub retired_at: Option<String>,
pub serial: String,
pub status: SamlIdpCredentialStatus,
pub tenant_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SamlIdpCredentialPromotion {
pub active: SamlIdpCredential,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub retired: Option<SamlIdpCredential>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SamlIdpCredentialStatus {
#[serde(rename = "active")]
Active,
#[serde(rename = "next")]
Next,
#[serde(rename = "retired")]
Retired,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SamlIdpInfo {
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub active_credential_id: Option<Option<Uuid>>,
pub entity_id: String,
pub metadata_served: bool,
pub metadata_url: String,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub next_credential_id: Option<Option<Uuid>>,
pub saml_available: bool,
pub saml_idp_enabled: bool,
pub slo_url: String,
pub sso_url: String,
pub tenant_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SamlIdpSlot {
#[serde(rename = "active")]
Active,
#[serde(rename = "next")]
Next,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SamlServiceProvider {
pub acs_urls: Vec<AcsEndpoint>,
pub allow_idp_initiated: bool,
pub allowed_groups: Vec<Uuid>,
pub attribute_mappings: Vec<AttributeMapping>,
pub created_at: String,
pub display_name: String,
pub enabled: bool,
pub encrypt_assertions: bool,
pub entity_id: String,
pub id: Uuid,
pub name_id_format: NameIdFormat,
pub sign_responses: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub slo_binding: Option<SamlBinding>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub slo_url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sp_encryption_cert_pem: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sp_signing_cert_pem: Option<String>,
pub tenant_id: Uuid,
pub updated_at: String,
pub want_authn_requests_signed: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SamlServiceProviderInput {
pub acs_urls: Vec<AcsEndpoint>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allow_idp_initiated: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allowed_groups: Option<Vec<Uuid>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub attribute_mappings: Option<Vec<AttributeMapping>>,
pub display_name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub encrypt_assertions: Option<bool>,
pub entity_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name_id_format: Option<NameIdFormat>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sign_responses: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub slo_binding: Option<SamlBinding>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub slo_url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sp_encryption_cert_pem: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sp_signing_cert_pem: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub want_authn_requests_signed: Option<bool>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SamlSpMetadataDraft {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub encryption_certificate_fingerprint: Option<String>,
pub service_provider: SamlServiceProviderInput,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub signing_certificate_fingerprint: Option<String>,
pub warnings: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ScimReconcileAccepted {
pub status: String,
pub target_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
#[non_exhaustive]
pub enum ScimTargetAuth {
#[serde(rename = "bearer")]
Bearer {},
#[serde(rename = "oauth2_client_credentials")]
Oauth2ClientCredentials {
client_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
scope: Option<String>,
token_url: String,
},
#[serde(other, skip_serializing)]
Unknown,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ScimTargetDeliveryState {
pub consecutive_failures: i64,
pub dead_lettered_total: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_failure_at: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_failure_reason: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_reconciled_at: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_success_at: Option<String>,
}
#[derive(Debug, Clone)]
pub struct ScimTargetInput {
pub auth: ScimTargetAuth,
pub base_url: String,
pub credential: Option<Sensitive<String>>,
pub deprovision: Option<DeprovisionPolicy>,
pub enabled: Option<bool>,
pub expected_updated_at: Option<String>,
pub name: String,
pub push_groups: Option<bool>,
pub scope: ScimTargetScope,
pub user_name_from: Option<UserNameSource>,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct ScimTargetInputWire {
pub(crate) auth: ScimTargetAuth,
pub(crate) base_url: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) credential: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) deprovision: Option<DeprovisionPolicy>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) expected_updated_at: Option<String>,
pub(crate) name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) push_groups: Option<bool>,
pub(crate) scope: ScimTargetScope,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) user_name_from: Option<UserNameSource>,
}
impl From<&ScimTargetInput> for ScimTargetInputWire {
fn from(v: &ScimTargetInput) -> Self {
Self {
auth: v.auth.clone(),
base_url: v.base_url.clone(),
credential: v
.credential
.as_ref()
.map(crate::management::error::expose_for_wire),
deprovision: v.deprovision.clone(),
enabled: v.enabled,
expected_updated_at: v.expected_updated_at.clone(),
name: v.name.clone(),
push_groups: v.push_groups,
scope: v.scope.clone(),
user_name_from: v.user_name_from.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ScimTargetResponse {
pub auth: ScimTargetAuth,
pub base_url: String,
pub created_at: String,
pub deprovision: DeprovisionPolicy,
pub enabled: bool,
pub id: Uuid,
pub name: String,
pub push_groups: bool,
pub scope: ScimTargetScope,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub state: Option<ScimTargetDeliveryState>,
pub tenant_id: Uuid,
pub updated_at: String,
pub user_name_from: UserNameSource,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
#[non_exhaustive]
pub enum ScimTargetScope {
#[serde(rename = "all_users")]
AllUsers {},
#[serde(rename = "groups")]
Groups {
group_ids: Vec<Uuid>,
},
#[serde(other, skip_serializing)]
Unknown,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ScimTokenResponse {
pub created_at: String,
pub created_by: Uuid,
pub expires_at: String,
pub id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_used_at: Option<String>,
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub revoked_at: Option<String>,
pub status: ScimTokenStatus,
pub tenant_id: Uuid,
pub user_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum ScimTokenStatus {
#[serde(rename = "active")]
Active,
#[serde(rename = "expired")]
Expired,
#[serde(rename = "revoked")]
Revoked,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Scope {
pub created_at: String,
pub description: String,
pub id: Uuid,
pub name: String,
pub resource_id: Uuid,
pub tenant_id: Uuid,
pub updated_at: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SecuritySettings {
pub certificate: CertificatePolicy,
pub created_at: String,
pub email: EmailVerificationPolicy,
pub id: Uuid,
pub lockout: LockoutPolicy,
pub mfa: MfaPolicy,
pub notification: NotificationPolicy,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub oauth2: Option<OAuth2Policy>,
pub oidc: OidcPolicy,
pub opaque: OpaquePolicy,
pub password: PasswordPolicy,
pub privacy: PrivacyPolicy,
pub scope: SettingsScope,
pub scope_id: Uuid,
pub token: TokenPolicy,
pub updated_at: String,
pub webauthn: WebauthnPolicy,
}
#[derive(Debug, Clone)]
pub struct ServiceAccountCreatedResponse {
pub client_id: String,
pub client_secret: Sensitive<String>,
pub created_at: String,
pub description: Option<String>,
pub id: Uuid,
pub name: String,
pub status: UserStatus,
pub tenant_id: Uuid,
pub updated_at: String,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct ServiceAccountCreatedResponseWire {
pub(crate) client_id: String,
pub(crate) client_secret: String,
pub(crate) created_at: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) description: Option<String>,
pub(crate) id: Uuid,
pub(crate) name: String,
pub(crate) status: UserStatus,
pub(crate) tenant_id: Uuid,
pub(crate) updated_at: String,
}
impl From<ServiceAccountCreatedResponseWire> for ServiceAccountCreatedResponse {
fn from(w: ServiceAccountCreatedResponseWire) -> Self {
Self {
client_id: w.client_id,
client_secret: crate::management::error::wrap_from_wire(w.client_secret),
created_at: w.created_at,
description: w.description,
id: w.id,
name: w.name,
status: w.status,
tenant_id: w.tenant_id,
updated_at: w.updated_at,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ServiceAccountResponse {
pub client_id: String,
pub created_at: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub id: Uuid,
pub name: String,
pub status: UserStatus,
pub tenant_id: Uuid,
pub updated_at: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionResponse {
pub amr: Vec<String>,
pub authenticated_at: String,
pub created_at: String,
pub expires_at: String,
pub id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ip_address: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub refresh_replay_at: Option<String>,
pub refresh_replay_grace_accepted: i32,
pub refresh_replay_refused: i32,
pub refresh_replay_verdict: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub user_agent: Option<String>,
}
#[derive(Debug, Clone)]
pub struct SetDirectoryConfig {
pub base_dn: String,
pub bind_dn: String,
pub bind_secret: Option<Sensitive<String>>,
pub enabled: bool,
pub group_base_dn: Option<String>,
pub group_filter: Option<String>,
pub group_mappings: Option<Vec<GroupMapping>>,
pub group_member_attribute: Option<String>,
pub group_nesting_depth: Option<i32>,
pub jit_provisioning: Option<bool>,
pub kind: DirectoryKind,
pub start_tls: bool,
pub sync_interval_secs: Option<i64>,
pub trust_anchors_pem: Option<Vec<String>>,
pub url: String,
pub user_attribute_map: Option<UserAttributeMap>,
pub user_filter: String,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct SetDirectoryConfigWire {
pub(crate) base_dn: String,
pub(crate) bind_dn: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) bind_secret: Option<String>,
pub(crate) enabled: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) group_base_dn: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) group_filter: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) group_mappings: Option<Vec<GroupMapping>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) group_member_attribute: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) group_nesting_depth: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) jit_provisioning: Option<bool>,
pub(crate) kind: DirectoryKind,
pub(crate) start_tls: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) sync_interval_secs: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) trust_anchors_pem: Option<Vec<String>>,
pub(crate) url: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) user_attribute_map: Option<UserAttributeMap>,
pub(crate) user_filter: String,
}
impl From<&SetDirectoryConfig> for SetDirectoryConfigWire {
fn from(v: &SetDirectoryConfig) -> Self {
Self {
base_dn: v.base_dn.clone(),
bind_dn: v.bind_dn.clone(),
bind_secret: v
.bind_secret
.as_ref()
.map(crate::management::error::expose_for_wire),
enabled: v.enabled,
group_base_dn: v.group_base_dn.clone(),
group_filter: v.group_filter.clone(),
group_mappings: v.group_mappings.clone(),
group_member_attribute: v.group_member_attribute.clone(),
group_nesting_depth: v.group_nesting_depth,
jit_provisioning: v.jit_provisioning,
kind: v.kind.clone(),
start_tls: v.start_tls,
sync_interval_secs: v.sync_interval_secs,
trust_anchors_pem: v.trust_anchors_pem.clone(),
url: v.url.clone(),
user_attribute_map: v.user_attribute_map.clone(),
user_filter: v.user_filter.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetMtlsTrustAnchor {
pub enabled: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetOrgEmailConfig {
pub enabled: bool,
pub from_email: String,
pub from_name: String,
pub provider: ProviderConfig,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reply_to: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SetOrgSettings {
pub access_token_lifetime_secs: i64,
pub admin_notifications_enabled: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cimd: Option<CimdPolicy>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_allowed_redirect_hosts: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_allowed_scopes: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_max_clients: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_unused_client_ttl_days: Option<i32>,
pub default_cert_validity_days: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub default_locale: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub deletion_grace_period_days: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dynamic_registration: Option<String>,
pub email_verification_grace_period_hours: i32,
pub email_verification_required: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub external_client_allowed_resources: Option<Vec<String>>,
pub hibp_check_enabled: bool,
pub lockout_backoff_multiplier: f64,
pub lockout_duration_secs: i64,
pub max_cert_validity_days: i32,
pub max_failed_login_attempts: i32,
pub max_lockout_duration_secs: i64,
pub mfa_challenge_lifetime_secs: i64,
pub mfa_enforced: bool,
pub min_length: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub opaque_ksf: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub opaque_mode: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub opaque_suite: Option<String>,
pub password_history_count: i32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub refresh_reuse_response: Option<RefreshReuseResponse>,
pub refresh_token_lifetime_secs: i64,
pub require_digits: bool,
pub require_lowercase: bool,
pub require_symbols: bool,
pub require_uppercase: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub saml_idp_enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sensitive_scopes_enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub server_cert_allowed_names: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ssf_enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub webauthn_user_verification: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SettingsScope {
Org,
Tenant,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SignAuditBatchRequest {
pub entry_ids: Vec<Uuid>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SignCertificateCsrRequest {
pub cert_type: CertificateType,
pub csr_pem: String,
pub issuer_ca_id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub subject_alt_names: Option<Vec<SubjectAltName>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
pub validity_days: i32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SignIntermediateCsrRequest {
pub csr_pem: String,
pub parent_ca_id: Uuid,
pub validity_days: i32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SignedAuditBatch {
pub batch_id: Uuid,
pub entry_ids: Vec<Uuid>,
pub signature_armored: String,
pub signed_at: String,
pub signing_key_id: Uuid,
pub tenant_id: Uuid,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SmtpConfig {
pub host: String,
pub port: i32,
pub starttls: bool,
pub username: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SsfDeliveryMethod {
#[serde(rename = "push")]
Push,
#[serde(rename = "poll")]
Poll,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SsfEventType {
#[serde(rename = "https://schemas.openid.net/secevent/caep/event-type/session-revoked")]
SessionRevoked,
#[serde(rename = "https://schemas.openid.net/secevent/caep/event-type/credential-change")]
CredentialChange,
#[serde(rename = "https://schemas.openid.net/secevent/caep/event-type/assurance-level-change")]
AssuranceLevelChange,
#[serde(rename = "https://schemas.openid.net/secevent/risc/event-type/account-disabled")]
AccountDisabled,
#[serde(rename = "https://schemas.openid.net/secevent/risc/event-type/account-enabled")]
AccountEnabled,
#[serde(rename = "https://schemas.openid.net/secevent/risc/event-type/account-purged")]
AccountPurged,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SsfStatusActor {
#[serde(rename = "admin")]
Admin,
#[serde(rename = "receiver")]
Receiver,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SsfStream {
pub audience: String,
pub authorization_header_set: bool,
pub created_at: String,
pub delivery_method: SsfDeliveryMethod,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub endpoint_url: Option<String>,
pub events_allowed: Vec<SsfEventType>,
pub events_delivered: Vec<SsfEventType>,
pub events_requested: Vec<SsfEventType>,
pub id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_verification_at: Option<String>,
pub receiver_client_id: String,
pub status: SsfStreamStatus,
pub status_actor: SsfStatusActor,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status_reason: Option<String>,
pub subject_format: SsfSubjectFormat,
pub tenant_id: Uuid,
pub transmitter_active: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub transmitter_inactive_reason: Option<String>,
pub updated_at: String,
}
#[derive(Debug, Clone)]
pub struct SsfStreamInput {
pub audience: String,
pub authorization_header: Option<Sensitive<String>>,
pub clear_authorization_header: Option<bool>,
pub delivery_method: SsfDeliveryMethod,
pub description: Option<String>,
pub endpoint_url: Option<String>,
pub events_allowed: Vec<SsfEventType>,
pub events_requested: Option<Vec<SsfEventType>>,
pub expected_updated_at: Option<String>,
pub receiver_client_id: String,
pub status: Option<SsfStreamStatus>,
pub status_reason: Option<String>,
pub subject_format: Option<SsfSubjectFormat>,
}
#[derive(Clone, Serialize, Deserialize)]
pub(crate) struct SsfStreamInputWire {
pub(crate) audience: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) authorization_header: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) clear_authorization_header: Option<bool>,
pub(crate) delivery_method: SsfDeliveryMethod,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) endpoint_url: Option<String>,
pub(crate) events_allowed: Vec<SsfEventType>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) events_requested: Option<Vec<SsfEventType>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) expected_updated_at: Option<String>,
pub(crate) receiver_client_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) status: Option<SsfStreamStatus>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) status_reason: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) subject_format: Option<SsfSubjectFormat>,
}
impl From<&SsfStreamInput> for SsfStreamInputWire {
fn from(v: &SsfStreamInput) -> Self {
Self {
audience: v.audience.clone(),
authorization_header: v
.authorization_header
.as_ref()
.map(crate::management::error::expose_for_wire),
clear_authorization_header: v.clear_authorization_header,
delivery_method: v.delivery_method.clone(),
description: v.description.clone(),
endpoint_url: v.endpoint_url.clone(),
events_allowed: v.events_allowed.clone(),
events_requested: v.events_requested.clone(),
expected_updated_at: v.expected_updated_at.clone(),
receiver_client_id: v.receiver_client_id.clone(),
status: v.status.clone(),
status_reason: v.status_reason.clone(),
subject_format: v.subject_format.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SsfStreamStatus {
#[serde(rename = "enabled")]
Enabled,
#[serde(rename = "paused")]
Paused,
#[serde(rename = "disabled")]
Disabled,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SsfSubjectFormat {
#[serde(rename = "iss_sub")]
IssSub,
#[serde(rename = "email")]
Email,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum SubjectAltName {
#[serde(rename = "dns")]
Dns(String),
#[serde(rename = "ip")]
Ip(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Tenant {
pub created_at: String,
pub id: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub kind: Option<TenantKind>,
pub metadata: serde_json::Value,
pub name: String,
pub organization_id: Uuid,
pub slug: String,
pub status: TenantStatus,
pub updated_at: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum TenantKind {
#[serde(rename = "standard")]
Standard,
#[serde(rename = "organization")]
Organization,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct TenantSettingsOverride {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub access_token_lifetime_secs: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub admin_notifications_enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cimd: Option<CimdPolicy>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_allowed_redirect_hosts: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_allowed_scopes: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_max_clients: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dcr_unused_client_ttl_days: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub default_cert_validity_days: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub default_locale: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub deletion_grace_period_days: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dynamic_registration: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub email_verification_grace_period_hours: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub email_verification_required: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub external_client_allowed_resources: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub hibp_check_enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub lockout_backoff_multiplier: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub lockout_duration_secs: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_cert_validity_days: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_failed_login_attempts: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_lockout_duration_secs: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mfa_challenge_lifetime_secs: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mfa_enforced: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub min_length: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub opaque_ksf: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub opaque_mode: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub opaque_suite: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub password_history_count: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub refresh_reuse_response: Option<RefreshReuseResponse>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub refresh_token_lifetime_secs: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub require_digits: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub require_lowercase: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub require_symbols: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub require_uppercase: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub saml_idp_enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sensitive_scopes_enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub server_cert_allowed_names: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ssf_enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub webauthn_user_verification: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum TenantStatus {
Active,
Suspended,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct TokenExchangeTrustRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub accepted_audiences: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_lifetime_secs: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_token_age_secs: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scope_map: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub subject_mapping: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TokenExchangeTrustResponse {
pub accepted_audiences: Vec<String>,
pub enabled: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_lifetime_secs: Option<i64>,
pub max_token_age_secs: i64,
pub scope_map: serde_json::Value,
pub subject_mapping: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TokenPolicy {
pub access_token_lifetime_secs: i64,
pub refresh_token_lifetime_secs: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum UnknownAaguidAction {
#[serde(rename = "allow")]
Allow,
#[serde(rename = "deny")]
Deny,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, Default)]
pub struct UpdateDirectoryConfig {
pub base_dn: Option<String>,
pub bind_dn: Option<String>,
pub bind_secret: Option<Sensitive<String>>,
pub enabled: Option<bool>,
pub group_base_dn: Option<Option<String>>,
pub group_filter: Option<Option<String>>,
pub group_mappings: Option<Vec<GroupMapping>>,
pub group_member_attribute: Option<String>,
pub group_nesting_depth: Option<i32>,
pub jit_provisioning: Option<bool>,
pub kind: Option<DirectoryKind>,
pub start_tls: Option<bool>,
pub sync_interval_secs: Option<i64>,
pub trust_anchors_pem: Option<Vec<String>>,
pub url: Option<String>,
pub user_attribute_map: Option<UserAttributeMap>,
pub user_filter: Option<String>,
}
#[derive(Clone, Serialize, Default, Deserialize)]
pub(crate) struct UpdateDirectoryConfigWire {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) base_dn: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) bind_dn: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) bind_secret: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) enabled: Option<bool>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) group_base_dn: Option<Option<String>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) group_filter: Option<Option<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) group_mappings: Option<Vec<GroupMapping>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) group_member_attribute: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) group_nesting_depth: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) jit_provisioning: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) kind: Option<DirectoryKind>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) start_tls: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) sync_interval_secs: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) trust_anchors_pem: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) user_attribute_map: Option<UserAttributeMap>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) user_filter: Option<String>,
}
impl From<&UpdateDirectoryConfig> for UpdateDirectoryConfigWire {
fn from(v: &UpdateDirectoryConfig) -> Self {
Self {
base_dn: v.base_dn.clone(),
bind_dn: v.bind_dn.clone(),
bind_secret: v
.bind_secret
.as_ref()
.map(crate::management::error::expose_for_wire),
enabled: v.enabled,
group_base_dn: v.group_base_dn.clone(),
group_filter: v.group_filter.clone(),
group_mappings: v.group_mappings.clone(),
group_member_attribute: v.group_member_attribute.clone(),
group_nesting_depth: v.group_nesting_depth,
jit_provisioning: v.jit_provisioning,
kind: v.kind.clone(),
start_tls: v.start_tls,
sync_interval_secs: v.sync_interval_secs,
trust_anchors_pem: v.trust_anchors_pem.clone(),
url: v.url.clone(),
user_attribute_map: v.user_attribute_map.clone(),
user_filter: v.user_filter.clone(),
}
}
}
#[derive(Debug, Clone, Default)]
pub struct UpdateFederationConfigRequest {
pub allow_sha1_signatures: Option<bool>,
pub allow_tenant_inheritance: Option<bool>,
pub allowed_algorithms: Option<Vec<String>>,
pub allowed_issuer_tenants: Option<Vec<String>>,
pub apple_key_id: Option<Option<String>>,
pub apple_team_id: Option<Option<String>>,
pub attribute_map: Option<serde_json::Value>,
pub authorization_endpoint: Option<Option<String>>,
pub button_icon: Option<Option<String>>,
pub client_id: Option<String>,
pub client_secret: Option<Sensitive<String>>,
pub enabled: Option<bool>,
pub idp_metadata_signing_cert_pem: Option<Option<String>>,
pub idp_signing_cert_pem: Option<Option<String>>,
pub metadata_url: Option<Option<String>>,
pub native_login: Option<NativeLoginTrustRequest>,
pub provider: Option<String>,
pub provider_slug: Option<Option<String>>,
pub require_pkce: Option<bool>,
pub scopes: Option<Vec<String>>,
pub token_endpoint: Option<Option<String>>,
pub token_exchange: Option<TokenExchangeTrustRequest>,
pub userinfo_endpoint: Option<Option<String>>,
}
#[derive(Clone, Serialize, Default, Deserialize)]
pub(crate) struct UpdateFederationConfigRequestWire {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) allow_sha1_signatures: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) allow_tenant_inheritance: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) allowed_algorithms: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) allowed_issuer_tenants: Option<Vec<String>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) apple_key_id: Option<Option<String>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) apple_team_id: Option<Option<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) attribute_map: Option<serde_json::Value>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) authorization_endpoint: Option<Option<String>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) button_icon: Option<Option<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) client_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) client_secret: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) enabled: Option<bool>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) idp_metadata_signing_cert_pem: Option<Option<String>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) idp_signing_cert_pem: Option<Option<String>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) metadata_url: Option<Option<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) native_login: Option<NativeLoginTrustRequest>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) provider: Option<String>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) provider_slug: Option<Option<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) require_pkce: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) scopes: Option<Vec<String>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) token_endpoint: Option<Option<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) token_exchange: Option<TokenExchangeTrustRequest>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::management::checks::explicit_null"
)]
pub(crate) userinfo_endpoint: Option<Option<String>>,
}
impl From<&UpdateFederationConfigRequest> for UpdateFederationConfigRequestWire {
fn from(v: &UpdateFederationConfigRequest) -> Self {
Self {
allow_sha1_signatures: v.allow_sha1_signatures,
allow_tenant_inheritance: v.allow_tenant_inheritance,
allowed_algorithms: v.allowed_algorithms.clone(),
allowed_issuer_tenants: v.allowed_issuer_tenants.clone(),
apple_key_id: v.apple_key_id.clone(),
apple_team_id: v.apple_team_id.clone(),
attribute_map: v.attribute_map.clone(),
authorization_endpoint: v.authorization_endpoint.clone(),
button_icon: v.button_icon.clone(),
client_id: v.client_id.clone(),
client_secret: v
.client_secret
.as_ref()
.map(crate::management::error::expose_for_wire),
enabled: v.enabled,
idp_metadata_signing_cert_pem: v.idp_metadata_signing_cert_pem.clone(),
idp_signing_cert_pem: v.idp_signing_cert_pem.clone(),
metadata_url: v.metadata_url.clone(),
native_login: v.native_login.clone(),
provider: v.provider.clone(),
provider_slug: v.provider_slug.clone(),
require_pkce: v.require_pkce,
scopes: v.scopes.clone(),
token_endpoint: v.token_endpoint.clone(),
token_exchange: v.token_exchange.clone(),
userinfo_endpoint: v.userinfo_endpoint.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdateGroup {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdateNotificationRuleRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub events: Option<Vec<NotificationEventType>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub recipient_emails: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub window_minutes: Option<i32>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdateOAuth2ClientRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allowed_resources: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub authn_request_params: Option<AuthnRequestParamsMode>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_authentication_request_signing_alg: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_client_notification_endpoint: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_logout_uri: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_token_delivery_mode: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub backchannel_user_code_parameter: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub browser_sso: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub default_idp: Option<Uuid>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dpop_bound_access_tokens: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dpop_require_nonce: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub grant_types: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub jwks: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub jwks_uri: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub post_logout_redirect_uris: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub profile: Option<ClientProfile>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub redirect_uris: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub require_par: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scopes: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub self_signed_tls_client_auth_thumbprints: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_client_auth_san_dns: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_client_auth_san_uri: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_client_auth_subject_dn: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tls_client_certificate_bound_access_tokens: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub token_endpoint_auth_method: Option<ClientAuthMethod>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdateOrganizationRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub slug: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdatePermissionRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub action: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdateReactorRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub events: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub failure_policy: Option<FailurePolicy>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mode: Option<ReactorMode>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub priority: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub timeout_ms: Option<i32>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdateResourceRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub parent_id: Option<Uuid>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdateRole {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub is_global: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdateScopeRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdateServiceAccount {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<UserStatus>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdateTenant {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub slug: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<TenantStatus>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct UpdateUserRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<UserStatus>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Debug, Clone, Default)]
pub struct UpdateWebhookRequest {
pub enabled: Option<bool>,
pub events: Option<Vec<String>>,
pub retry_policy: Option<RetryPolicy>,
pub secret: Option<Sensitive<String>>,
pub url: Option<String>,
}
#[derive(Clone, Serialize, Default, Deserialize)]
pub(crate) struct UpdateWebhookRequestWire {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) events: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) retry_policy: Option<RetryPolicy>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) secret: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(crate) url: Option<String>,
}
impl From<&UpdateWebhookRequest> for UpdateWebhookRequestWire {
fn from(v: &UpdateWebhookRequest) -> Self {
Self {
enabled: v.enabled,
events: v.events.clone(),
retry_policy: v.retry_policy.clone(),
secret: v
.secret
.as_ref()
.map(crate::management::error::expose_for_wire),
url: v.url.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UserAttributeMap {
pub display_name: String,
pub email: String,
pub external_id: String,
pub username: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum UserNameSource {
#[serde(rename = "username")]
Username,
#[serde(rename = "email")]
Email,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UserResponse {
pub created_at: String,
pub email: String,
pub email_verified: bool,
pub failed_login_attempts: i32,
pub id: Uuid,
pub is_locked: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub locked_until: Option<String>,
pub metadata: serde_json::Value,
pub mfa_enabled: bool,
pub status: UserStatus,
pub tenant_id: Uuid,
pub updated_at: String,
pub username: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum UserStatus {
Active,
Inactive,
Locked,
PendingVerification,
Anonymized,
Deleted,
#[serde(untagged)]
Unknown(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WebauthnAttestationPolicy {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allowed_aaguids: Option<Vec<Uuid>>,
pub block_revoked_status: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub blocked_aaguids: Option<Vec<Uuid>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub min_certification: Option<CertificationLevel>,
pub mode: AttestationMode,
pub require_fido_certified: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub unknown_aaguid: Option<UnknownAaguidAction>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WebauthnPolicy {
pub webauthn_user_verification: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WebhookResponse {
pub created_at: String,
pub enabled: bool,
pub events: Vec<String>,
pub id: Uuid,
pub retry_policy: RetryPolicy,
pub tenant_id: Uuid,
pub updated_at: String,
pub url: String,
}
#[cfg(test)]
mod wire_twin_tests {
#[test]
fn no_wire_twin_is_debug() {
let debug: Vec<&str> = [
(
"CreateFederationConfigRequestWire",
crate::sensitive::implements_debug!(super::CreateFederationConfigRequestWire),
),
(
"CreateRegistrationTokenResponseWire",
crate::sensitive::implements_debug!(super::CreateRegistrationTokenResponseWire),
),
(
"CreateScimTokenResponseWire",
crate::sensitive::implements_debug!(super::CreateScimTokenResponseWire),
),
(
"CreateUserRequestWire",
crate::sensitive::implements_debug!(super::CreateUserRequestWire),
),
(
"CreateWebhookRequestWire",
crate::sensitive::implements_debug!(super::CreateWebhookRequestWire),
),
(
"GeneratedCaCertificateWire",
crate::sensitive::implements_debug!(super::GeneratedCaCertificateWire),
),
(
"GeneratedCertificateWire",
crate::sensitive::implements_debug!(super::GeneratedCertificateWire),
),
(
"GeneratedPgpKeyWire",
crate::sensitive::implements_debug!(super::GeneratedPgpKeyWire),
),
(
"ImportCaCertificateRequestWire",
crate::sensitive::implements_debug!(super::ImportCaCertificateRequestWire),
),
(
"OAuth2ClientCreatedResponseWire",
crate::sensitive::implements_debug!(super::OAuth2ClientCreatedResponseWire),
),
(
"RotateSecretResponseWire",
crate::sensitive::implements_debug!(super::RotateSecretResponseWire),
),
(
"ScimTargetInputWire",
crate::sensitive::implements_debug!(super::ScimTargetInputWire),
),
(
"ServiceAccountCreatedResponseWire",
crate::sensitive::implements_debug!(super::ServiceAccountCreatedResponseWire),
),
(
"SetDirectoryConfigWire",
crate::sensitive::implements_debug!(super::SetDirectoryConfigWire),
),
(
"SsfStreamInputWire",
crate::sensitive::implements_debug!(super::SsfStreamInputWire),
),
(
"UpdateDirectoryConfigWire",
crate::sensitive::implements_debug!(super::UpdateDirectoryConfigWire),
),
(
"UpdateFederationConfigRequestWire",
crate::sensitive::implements_debug!(super::UpdateFederationConfigRequestWire),
),
(
"UpdateWebhookRequestWire",
crate::sensitive::implements_debug!(super::UpdateWebhookRequestWire),
),
]
.into_iter()
.filter(|(_, is_debug)| *is_debug)
.map(|(name, _)| name)
.collect();
assert!(debug.is_empty(), "wire twins deriving Debug: {debug:?}");
}
}