Enum Event 

#[non_exhaustive]
pub enum Event {
    CapabilitiesAcknowledged {
        names: Vec<String>,
    },
    Registered {
        nick: String,
    },
    IsupportToken {
        token: String,
        value: Option<String>,
    },
    LoggedIn {
        account: String,
    },
    SaslFailed {
        reason: SaslFailure,
    },
    NickInUse {
        refused: String,
        trying: String,
    },
    ModelChanged {
        change: Change,
    },
    LinkDead,
    ReconnectAfter {
        after_ms: u64,
    },
    ReconnectAbandoned,
    CommandTimedOut {
        command: String,
    },
    AllowedCommandsChanged,
    BotsChanged {
        nick: String,
    },
    AuthToken {
        service: String,
        endpoint: String,
        token: String,
    },
    Voice {
        channel: String,
        signal: Signal,
    },
    TypingChanged {
        target: String,
        nick: String,
        active: bool,
    },
    PresenceChanged {
        nick: String,
        online: bool,
    },
    ServerReply {
        severity: Severity,
        command: String,
        code: String,
        context: Vec<String>,
        text: String,
    },
    RawLine {
        message: Message,
    },
}

Something the host needs to know about.

Events are drained with Client::poll_event rather than delivered through a callback, because a callback needs a different lifetime, threading and re-entrancy contract in every language this engine is bound into.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

CapabilitiesAcknowledged

A capability was acknowledged, and whatever it enables is now live.

Fields

names: Vec<String>

The capability names, as acknowledged.

Registered

Registration finished. 001 arrived and the nick is settled.

Fields

nick: String

The nick the server actually gave us, which may differ from the one we asked for.

IsupportToken

An ISUPPORT token arrived. Emitted per token so a host can react to one without diffing.

Fields

token: String

The token name, such as CHANMODES.

value: Option<String>

Its value, absent for a boolean token, present and empty for TOKEN=.

LoggedIn

Authentication succeeded.

Fields

account: String

The account the server logged us in as.

SaslFailed

Authentication did not succeed. Registration continues unauthenticated.

Fields

reason: SaslFailure

Why it ended.

NickInUse

The server refused a nick and the engine is trying another.

Fields

refused: String

The nick that was refused.

trying: String

What is being tried instead.

ModelChanged

The model changed.

Fields

change: Change

What changed.

LinkDead

The link went quiet for too long and should be treated as dead. The host closes its socket and waits for Event::ReconnectAfter.

ReconnectAfter

Time to open a new connection. The host dials and calls Client::handle_connected.

Fields

after_ms: u64

How long the host should wait first.

ReconnectAbandoned

Reconnecting has been given up on after too many attempts.

CommandTimedOut

A command we labelled never got its reply.

Fields

command: String

The command that went unanswered.

AllowedCommandsChanged

The set of commands the server allows us changed.

BotsChanged

What we know about a bot changed. Read it back from Client::bots.

Fields

nick: String

The bot the server told us about.

AuthToken

The server minted a bearer token for one of its services.

Fields

service: String

The service it is for, as the server spells it.

endpoint: String

Where to present it.

token: String

The token itself.

Voice

A voice signalling frame arrived, and the room state has already been updated for it.

The host handles the media plane: this carries the session descriptions and candidates it needs, and nothing that touches a track.

Fields

channel: String

The channel the room belongs to.

signal: Signal

The frame.

TypingChanged

Someone started or stopped composing a message.

Fields

target: String

The channel or conversation they are composing in.

nick: String

Who.

active: bool

True when they are composing now.

PresenceChanged

Someone we watch came online or went offline.

Fields

nick: String

Who.

online: bool

True when they are here now.

ServerReply

The server reported the outcome of something, through standard-replies.

Fields

severity: Severity

How serious it is.

command: String

The command it concerns, or * when the server did not say.

code: String

The machine-readable code, such as ACCOUNT_REQUIRED_TO_CONNECT.

context: Vec<String>

Any further parameters the server gave, before the description.

text: String

The human-readable description.

RawLine

A line arrived that the engine has no dedicated handling for yet. Everything is surfaced, so a host is never blind to traffic the engine does not model.

Fields

message: Message

The parsed line.

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Event

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Event

impl PartialEq for Event

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Event

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Event

impl TS for Event

const DOCS: Option<&'static str>

JSDoc comment to describe this type in TypeScript - when TS is derived, docs are automatically read from your doc comments or #[doc = ".."] attributes

type WithoutGenerics = Event

If this type does not have generic parameters, then WithoutGenerics should just be Self. If the type does have generic parameters, then all generic parameters must be replaced with a dummy type, e.g ts_rs::Dummy or (). The only requirement for these dummy types is that EXPORT_TO must be None.

fn ident() -> String

Identifier of this type, excluding generic parameters.

fn name() -> String

Name of this type in TypeScript, including generic parameters

fn decl_concrete() -> String

Declaration of this type using the supplied generic arguments. The resulting TypeScript definition will not be generic. For that, see TS::decl(). If this type is not generic, then this function is equivalent to TS::decl().

fn decl() -> String

Declaration of this type, e.g. type User = { user_id: number, ... }. This function will panic if the type has no declaration.

fn inline() -> String

Formats this types definition in TypeScript, e.g { user_id: number }. This function will panic if the type cannot be inlined.

fn inline_flattened() -> String

Flatten a type declaration.
This function will panic if the type cannot be flattened.

fn visit_generics(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all type parameters of this type.

fn output_path() -> Option<&'static Path>

Returns the output path to where T should be exported.
The returned path does not include the base directory from TS_RS_EXPORT_DIR.

fn visit_dependencies(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all dependency of this type.

fn dependencies() -> Vec<Dependency>

where Self: 'static,

Resolves all dependencies of this type recursively.

fn export() -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem. To export this type together with all of its dependencies, use [TS::export_all].

fn export_all() -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem, together with all of its dependencies.
To export only this type, without its dependencies, use [TS::export].

fn export_all_to(out_dir: impl AsRef<Path>) -> Result<(), ExportError>

where Self: 'static,

Manually export this type into the given directory, together with all of its dependencies.
To export only this type, without its dependencies, use [TS::export].

fn export_to_string() -> Result<String, ExportError>

where Self: 'static,

Manually generate bindings for this type, returning a String.
This function does not format the output, even if the format feature is enabled.

fn default_output_path() -> Option<PathBuf>

Returns the output path to where T should be exported.