Enum DocumentType 

pub enum DocumentType {
    Model,
    Diagram,
    Analysis,
}

The type/kind of a document, without any associated content.

Variants

Model

Diagram

Analysis

Trait Implementations

impl Clone for DocumentType

fn clone(&self) -> DocumentType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DocumentType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DocumentType

fn deserialize<__D>( __deserializer: __D, ) -> Result<DocumentType, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<DocumentType> for JsValue

where DocumentType: Serialize,

fn from(value: DocumentType) -> JsValue

Converts to this type from the input type.

impl FromStr for DocumentType

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<DocumentType, <DocumentType as FromStr>::Err>

Parses a string s to return a value of this type.

impl FromWasmAbi for DocumentType

where DocumentType: DeserializeOwned,

type Abi = <JsType as FromWasmAbi>::Abi

The Wasm ABI type that this converts from when coming back out from the ABI boundary.

unsafe fn from_abi(js: <DocumentType as FromWasmAbi>::Abi) -> DocumentType

Recover a Self from Self::Abi.

impl Hydrate for DocumentType

fn hydrate_string(val: &str) -> Result<DocumentType, HydrateError>

fn hydrate<D>(doc: &D, obj: &ExId, prop: Prop<'_>) -> Result<Self, HydrateError>

where D: ReadDoc,

fn hydrate_scalar(s: Cow<'_, ScalarValue>) -> Result<Self, HydrateError>

fn hydrate_bool(_b: bool) -> Result<Self, HydrateError>

fn hydrate_bytes(_bytes: &[u8]) -> Result<Self, HydrateError>

fn hydrate_f64(_f: f64) -> Result<Self, HydrateError>

fn hydrate_counter(_c: i64) -> Result<Self, HydrateError>

fn hydrate_int(_i: i64) -> Result<Self, HydrateError>

fn hydrate_uint(_u: u64) -> Result<Self, HydrateError>

fn hydrate_timestamp(_t: i64) -> Result<Self, HydrateError>

fn hydrate_unknown(_type_code: u8, _bytes: &[u8]) -> Result<Self, HydrateError>

fn hydrate_map<D>(_doc: &D, _obj: &ExId) -> Result<Self, HydrateError>

where D: ReadDoc,

fn hydrate_seq<D>(_doc: &D, _obj: &ExId) -> Result<Self, HydrateError>

where D: ReadDoc,

fn hydrate_text<D>(_doc: &D, _obj: &ExId) -> Result<Self, HydrateError>

where D: ReadDoc,

fn hydrate_none() -> Result<Self, HydrateError>

impl IntoWasmAbi for &DocumentType

where DocumentType: Serialize,

type Abi = <JsType as IntoWasmAbi>::Abi

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> <&DocumentType as IntoWasmAbi>::Abi

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl IntoWasmAbi for DocumentType

where DocumentType: Serialize,

type Abi = <JsType as IntoWasmAbi>::Abi

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> <DocumentType as IntoWasmAbi>::Abi

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl OptionFromWasmAbi for DocumentType

where DocumentType: DeserializeOwned,

fn is_none(js: &<DocumentType as FromWasmAbi>::Abi) -> bool

Tests whether the argument is a “none” instance. If so it will be deserialized as None, and otherwise it will be passed to FromWasmAbi.

impl OptionIntoWasmAbi for DocumentType

where DocumentType: Serialize,

fn none() -> <DocumentType as IntoWasmAbi>::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

impl PartialEq for DocumentType

fn eq(&self, other: &DocumentType) -> 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 Reconcile for DocumentType

type Key<'k> = ___DocumentTypeReconcileKeyType

The type of the key of this item.

fn reconcile<__R123>( &self, reconciler: __R123, ) -> Result<(), <__R123 as Reconciler>::Error>

where __R123: Reconciler,

Reconcile this item with the document

fn hydrate_key<'k, D>( doc: &D, obj: &ExId, prop: Prop<'_>, ) -> Result<LoadKey<<DocumentType as Reconcile>::Key<'k>>, ReconcileError>

where D: ReadDoc,

Hydrate the key for this Object

fn key<'k>(&'k self) -> LoadKey<<DocumentType as Reconcile>::Key<'k>>

Get the key from an instance of Self

impl RefFromWasmAbi for DocumentType

where DocumentType: DeserializeOwned,

type Abi = <JsType as RefFromWasmAbi>::Abi

The Wasm ABI type references to Self are recovered from.

type Anchor = SelfOwner<DocumentType>

The type that holds the reference to Self for the duration of the invocation of the function that has an &Self parameter. This is required to ensure that the lifetimes don’t persist beyond one function call, and so that they remain anonymous.

unsafe fn ref_from_abi( js: <DocumentType as RefFromWasmAbi>::Abi, ) -> <DocumentType as RefFromWasmAbi>::Anchor

Recover a Self::Anchor from Self::Abi.

impl Serialize for DocumentType

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TS for DocumentType

type WithoutGenerics = DocumentType

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.

type OptionInnerType = DocumentType

If the implementing type is std::option::Option<T>, then this associated type is set to T. All other implementations of TS should set this type to Self instead.

fn ident() -> String

Identifier of this type, excluding generic parameters.

fn docs() -> Option<String>

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

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 DocumentType: 'static,

Iterates over all type parameters of this type.

fn output_path() -> Option<PathBuf>

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 DocumentType: '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.

impl Tsify for DocumentType

const DECL: &'static str = "/**\n * The type/kind of a document, without any associated content.\n */\nexport type DocumentType = \"model\" | \"diagram\" | \"analysis\";"

const SERIALIZATION_CONFIG: SerializationConfig

type JsType = JsType

fn into_js(&self) -> Result<Self::JsType, Error>

where Self: Serialize,

fn from_js<T>(js: T) -> Result<Self, Error>

where T: Into<JsValue>, Self: DeserializeOwned,

impl VectorFromWasmAbi for DocumentType

where DocumentType: DeserializeOwned,

type Abi = <JsType as VectorFromWasmAbi>::Abi

unsafe fn vector_from_abi( js: <DocumentType as VectorFromWasmAbi>::Abi, ) -> Box<[DocumentType]>

impl VectorIntoWasmAbi for DocumentType

where DocumentType: Serialize,

type Abi = <JsType as VectorIntoWasmAbi>::Abi

fn vector_into_abi( vector: Box<[DocumentType]>, ) -> <DocumentType as VectorIntoWasmAbi>::Abi

impl Copy for DocumentType

impl Eq for DocumentType

impl StructuralPartialEq for DocumentType