Enum PlannedAction 

pub enum PlannedAction {
    Move {
        to: String,
    },
    Copy {
        to: String,
    },
    AddFlags {
        flags: Vec<Flag>,
    },
    RemoveFlags {
        flags: Vec<Flag>,
    },
    SetFlags {
        flags: Vec<Flag>,
    },
    MarkRead,
    Delete,
    Forward {
        to: String,
    },
    Vacation(VacationReply),
    Notify {
        method: String,
        message: String,
    },
}

A single planned action ready for execution by the host application.

Variants

Move

Move to folder.

Fields

to: String

Destination folder.

Copy

Copy to folder.

Fields

to: String

Destination folder.

AddFlags

Add flags (RFC 5232 addflag).

Fields

flags: Vec<Flag>

Flags to add.

RemoveFlags

Remove flags (RFC 5232 removeflag).

Fields

flags: Vec<Flag>

Flags to remove.

SetFlags

Replace the flag set (RFC 5232 setflag).

Fields

flags: Vec<Flag>

The new flag set.

MarkRead

Mark as read.

Delete

Delete (move to trash).

Forward

Forward to address.

Fields

to: String

Recipient email.

Vacation(VacationReply)

Send an automated reply (RFC 5230 vacation). The engine evaluates the reply — dedup, routing, default subject — but never sends: handing it to an SMTP transport is the host’s responsibility.

Notify

Emit a notification to an external method (RFC 5436 notify). Delivery is the host’s responsibility.

Fields

method: String

Notification method URI (e.g. mailto:ops@example.com).

message: String

Message body (:message).

Trait Implementations

impl Clone for PlannedAction

fn clone(&self) -> PlannedAction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PlannedAction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for PlannedAction

impl From<&Action> for PlannedAction

fn from(action: &Action) -> Self

Converts to this type from the input type.

impl PartialEq for PlannedAction

fn eq(&self, other: &PlannedAction) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for PlannedAction