mhome-messaging-api 1.0.3

use crate::{ConversationAudience, ExternalActor, MessagingAddress};
use serde::{Deserialize, Serialize};
use serde_json::Value;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Placement {
    Local,
    Cloud,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct FrontendProvider {
    pub provider: String,
    pub deprecated: bool,
    pub supported_placements: Vec<Placement>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderListRequest {
    pub placement: Placement,
    pub frontend_providers: Vec<FrontendProvider>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderMetadata {
    pub provider: String,
    pub display_name: String,
    pub placement: Placement,
    pub deprecated: bool,
    pub available: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub disabled_reason: Option<String>,
    pub setup_flow: String,
    pub audiences: Vec<ConversationAudience>,
    pub inbound_capabilities: Vec<ContentCapability>,
    pub outbound_capabilities: Vec<ContentCapability>,
    pub delivery_mode: DeliveryMode,
    pub projections: ProjectionCapabilities,
    pub management_operations: Vec<ManagementOperation>,
    pub provider_data: Value,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProjectionCapabilities {
    pub notification: ProjectionCapability,
    pub dialog: ProjectionCapability,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProjectionCapability {
    pub supported: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<ProjectionUnsupportedReason>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ProjectionUnsupportedReason {
    NoProactiveDelivery,
    NoInteractiveActions,
    SessionWindowOnly,
    ProviderUnconfigured,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct RouteProjectionSettings {
    pub notification: NotificationProjectionSetting,
    pub dialog: DialogProjectionSetting,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct NotificationProjectionSetting {
    pub enabled: bool,
    pub levels: Vec<NotificationProjectionLevel>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum NotificationProjectionLevel {
    Alert,
    Notify,
    Chat,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct DialogProjectionSetting {
    pub enabled: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct RouteProjectionSettingsUpdate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notification: Option<NotificationProjectionSettingUpdate>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dialog: Option<DialogProjectionSettingUpdate>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct NotificationProjectionSettingUpdate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub levels: Option<Vec<NotificationProjectionLevel>>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct DialogProjectionSettingUpdate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ContentCapability {
    Text,
    Markdown,
    Image,
    Audio,
    Video,
    File,
    Action,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum DeliveryMode {
    Unrestricted,
    SessionWindow,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ManagementOperation {
    #[serde(rename = "provider_account.list")]
    ProviderAccountList,
    #[serde(rename = "provider_account.update")]
    ProviderAccountUpdate,
    #[serde(rename = "provider_account.delete")]
    ProviderAccountDelete,
    #[serde(rename = "provider_account.test")]
    ProviderAccountTest,
    #[serde(rename = "provider_account.status")]
    ProviderAccountStatus,
    #[serde(rename = "shared_account_grant.create")]
    SharedAccountGrantCreate,
    #[serde(rename = "shared_account_grant.delete")]
    SharedAccountGrantDelete,
    #[serde(rename = "shared_account_grant.list")]
    SharedAccountGrantList,
    #[serde(rename = "route.list")]
    RouteList,
    #[serde(rename = "route.update")]
    RouteUpdate,
    #[serde(rename = "route.delete")]
    RouteDelete,
    #[serde(rename = "setup.options")]
    SetupOptions,
    #[serde(rename = "setup.start")]
    SetupStart,
    #[serde(rename = "setup.status")]
    SetupStatus,
    #[serde(rename = "surface.list")]
    SurfaceList,
    #[serde(rename = "surface.dismiss")]
    SurfaceDismiss,
    #[serde(rename = "surface.bind_code.create")]
    SurfaceBindCodeCreate,
    #[serde(rename = "actor.link_code.create")]
    ActorLinkCodeCreate,
    #[serde(rename = "actor.link_claim.status")]
    ActorLinkClaimStatus,
    #[serde(rename = "actor.link_claim.confirm")]
    ActorLinkClaimConfirm,
    #[serde(rename = "actor.link.list")]
    ActorLinkList,
    #[serde(rename = "actor.link.delete")]
    ActorLinkDelete,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderListResponse {
    pub providers: Vec<ProviderMetadata>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderPlacementRequest {
    pub provider: String,
    pub placement: Placement,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderAccountUpdateRequest {
    pub provider: String,
    pub placement: Placement,
    pub account_id: String,
    pub data: Value,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderAccountRequest {
    pub provider: String,
    pub placement: Placement,
    pub account_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderAccountTestRequest {
    pub provider: String,
    pub placement: Placement,
    pub data: Value,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ProviderAccountOwnership {
    System,
    User,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderAccount {
    pub provider: String,
    pub placement: Placement,
    pub account_id: String,
    pub ownership: ProviderAccountOwnership,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    pub enabled: bool,
    pub status: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status_message: Option<String>,
    pub provider_data: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderAccountListResponse {
    pub accounts: Vec<ProviderAccount>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderAccountUpdateResponse {
    pub account: ProviderAccount,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderAccountTestResponse {
    pub result: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderStatus {
    pub provider: String,
    pub placement: Placement,
    pub enabled: bool,
    pub provider_data: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProviderAccountStatusResponse {
    pub status: ProviderStatus,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct MutationResponse {
    pub success: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SharedAccountGrantRequest {
    pub provider: String,
    pub placement: Placement,
    pub account_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SharedAccountGrantListRequest {
    pub provider: String,
    pub placement: Placement,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SharedAccountGrant {
    pub provider: String,
    pub placement: Placement,
    pub account_id: String,
    pub tenant_id: String,
    pub scope_id: String,
    pub granted_by_user_id: String,
    pub created_at_ms: i64,
    pub updated_at_ms: i64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SharedAccountGrantListResponse {
    pub grants: Vec<SharedAccountGrant>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct RouteListRequest {
    pub provider: String,
    pub placement: Placement,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub audience: Option<ConversationAudience>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct RouteRequest {
    pub provider: String,
    pub placement: Placement,
    pub route_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(
    tag = "audience",
    rename_all = "lowercase",
    rename_all_fields = "camelCase",
    deny_unknown_fields
)]
pub enum RouteUpdateRequest {
    Personal {
        provider: String,
        placement: Placement,
        route_id: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        scope_id: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        enabled: Option<bool>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        projections: Option<RouteProjectionSettingsUpdate>,
    },
    Shared {
        provider: String,
        placement: Placement,
        route_id: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        enabled: Option<bool>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        projections: Option<RouteProjectionSettingsUpdate>,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(
    tag = "audience",
    rename_all = "lowercase",
    rename_all_fields = "camelCase",
    deny_unknown_fields
)]
pub enum MessagingRoute {
    Personal {
        provider: String,
        placement: Placement,
        route_id: String,
        account_id: String,
        conversation_id: String,
        external_actor_id: String,
        tenant_id: String,
        user_id: String,
        scope_id: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        display_name: Option<String>,
        enabled: bool,
        projections: RouteProjectionSettings,
        provider_data: Value,
    },
    Shared {
        provider: String,
        placement: Placement,
        route_id: String,
        account_id: String,
        conversation_id: String,
        tenant_id: String,
        scope_id: String,
        bound_by_user_id: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        display_name: Option<String>,
        enabled: bool,
        projections: RouteProjectionSettings,
        provider_data: Value,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct RouteListResponse {
    pub routes: Vec<MessagingRoute>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct RouteUpdateResponse {
    pub route: MessagingRoute,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SetupStartRequest {
    pub provider: String,
    pub placement: Placement,
    pub data: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SetupOptionsResponse {
    pub options: Value,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SetupStatusRequest {
    pub provider: String,
    pub placement: Placement,
    pub setup_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SetupAction {
    #[serde(rename = "type")]
    pub kind: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SetupState {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub setup_id: Option<String>,
    pub status: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub action: Option<SetupAction>,
    pub provider_data: Value,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub route_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SetupResponse {
    pub setup: SetupState,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SurfaceState {
    Pending,
    Bound,
    Dismissed,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SurfaceListRequest {
    pub provider: String,
    pub placement: Placement,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub state: Option<SurfaceState>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct MessagingSurface {
    pub provider: String,
    pub placement: Placement,
    pub account_id: String,
    pub surface_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    pub state: SurfaceState,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scope_id: Option<String>,
    pub first_seen_at_ms: i64,
    pub last_seen_at_ms: i64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SurfaceListResponse {
    pub surfaces: Vec<MessagingSurface>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SurfaceRequest {
    pub provider: String,
    pub placement: Placement,
    pub surface_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SurfaceBindCodeCreateRequest {
    pub provider: String,
    pub placement: Placement,
    pub surface_id: String,
    pub scope_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkCodeCreateRequest {
    pub provider: String,
    pub placement: Placement,
    pub account_id: String,
    pub target: ActorLinkTarget,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(
    tag = "audience",
    rename_all = "lowercase",
    rename_all_fields = "camelCase",
    deny_unknown_fields
)]
pub enum ActorLinkTarget {
    Personal,
    Shared { surface_id: String },
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ChallengeCode {
    pub code: String,
    pub command: String,
    pub expires_at_ms: i64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkChallenge {
    pub challenge_id: String,
    pub code: String,
    pub command: String,
    pub target: ActorLinkTarget,
    pub expires_at_ms: i64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkChallengeResponse {
    pub challenge: ActorLinkChallenge,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkCandidate {
    pub actor: ExternalActor,
    pub address: MessagingAddress,
    pub event_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkClaim {
    pub challenge_id: String,
    pub provider: String,
    pub placement: Placement,
    pub account_id: String,
    pub target: ActorLinkTarget,
    pub expires_at_ms: i64,
    pub lifecycle: ActorLinkClaimLifecycle,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(
    tag = "state",
    rename_all = "snake_case",
    rename_all_fields = "camelCase",
    deny_unknown_fields
)]
pub enum ActorLinkClaimLifecycle {
    Issued,
    AwaitingConfirmation {
        candidate: ActorLinkCandidate,
    },
    Confirming {
        candidate: ActorLinkCandidate,
    },
    Completed {
        candidate: ActorLinkCandidate,
        link_id: String,
    },
    Superseded,
    Expired,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkClaimRequest {
    pub provider: String,
    pub placement: Placement,
    pub challenge_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkClaimResponse {
    pub claim: ActorLinkClaim,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkClaimEvent {
    pub claim: ActorLinkClaim,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ChallengeCodeResponse {
    pub challenge: ChallengeCode,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkListRequest {
    pub provider: String,
    pub placement: Placement,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkView {
    pub link_id: String,
    pub provider: String,
    pub placement: Placement,
    pub account_id: String,
    pub external_user_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    pub created_at_ms: i64,
    pub updated_at_ms: i64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkListResponse {
    pub links: Vec<ActorLinkView>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ActorLinkDeleteRequest {
    pub provider: String,
    pub placement: Placement,
    pub link_id: String,
}