Tauri Specta

https://docs.rs/tauri-specta/2.0.0-rc.21
Admin
Tauri Specta is a Rust crate that generates TypeScript or JSDoc bindings to provide type-safe...
Tokens:26,334
Snippets:243
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Basic Tauri Specta Setup with TypeScript Export

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

This example demonstrates a basic setup for Tauri Specta, exporting generated TypeScript bindings to a file. It's intended to be copied into your `main.rs` file to initialize the application with API bindings. Ensure this is placed within a `#[cfg(debug_assertions)]` block for conditional compilation during development.

```rust
use tauri_specta::{collect_commands, collect_events, Builder};
use specta_typescript::Typescript;


let mut builder = <Builder>::new()
    .commands(collect_commands![])
    .events(collect_events![]);

#[cfg(debug_assertions)]
builder
    .export(Typescript::default(), "../src/bindings.ts")
    .expect("Failed to export typescript bindings");

tauri::Builder::default()
    .invoke_handler(builder.invoke_handler()) // < Required for commands to work
    .setup(move |app| {
        builder.mount_events(app); // < Required for events to work

        Ok(())
    })
    // on an actual app, remove the string argument
    .run(tauri::generate_context!("tests/tauri.conf.json"))
    .expect("error while running tauri application");

```

--------------------------------

### Tauri Specta Setup with Typescript

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/index.html

A minimal Rust example demonstrating how to set up Tauri Specta with Typescript. Commands must be annotated with `#[tauri::command]` and `#[specta::specta]`. The builder exports bindings to a file during debug builds.

```rust
#![cfg_attr(
    all(not(debug_assertions), target_os = "windows"),
    windows_subsystem = "windows"
)]

use serde::{Deserialize, Serialize};
use specta_typescript::Typescript;
use tauri_specta::{collect_commands, Builder};

#[tauri::command]
#[specta::specta] // < You must annotate your commands
fn hello_world(my_name: String) -> String {
    format!("Hello, {my_name}! You've been greeted from Rust!")
}

fn main() {
    let mut builder = Builder::<tauri::Wry>::new()
        // Then register them (separated by a comma)
        .commands(collect_commands![hello_world,]);

    #[cfg(debug_assertions)] // <- Only export on non-release builds
    builder
        .export(Typescript::default(), "../src/bindings.ts")
        .expect("Failed to export typescript bindings");

    tauri::Builder::default()
        // and finally tell Tauri how to invoke them
        .invoke_handler(builder.invoke_handler())
        .setup(move |app| {
            // This is also required if you want to use events
            builder.mount_events(app);

            Ok(())
        })
        // on an actual app, remove the string argument
        .run(tauri::generate_context!("tests/tauri.conf.json"))
        .expect("error while running tauri application");
}
```

--------------------------------

### Frontend Usage Example

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/index.html

Import commands and events from the generated bindings file to interact with your Rust backend.

```javascript
import { commands, events } from "./bindings"; // This should point to the file we export from Rust

console.log(await commands.greet("Brendan"));
```

--------------------------------

### Frontend Import Example

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/lib.rs.html

This is how you would import commands and events from the generated bindings file on your frontend.

```typescript
import { commands, events } from "./bindings"; // This should point to the file we export from Rust

```

--------------------------------

### Setup Tauri Specta with Typescript

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/index.html

Minimal setup for Tauri Specta with Typescript. Annotate commands with `#[specta::specta]` and export bindings in debug builds.

```rust
#![cfg_attr(
    all(not(debug_assertions), target_os = "windows"),
    windows_subsystem = "windows"
)]

use serde::{Deserialize, Serialize};
use specta_typescript::Typescript;
use tauri_specta::{collect_commands, Builder};

#[tauri::command]
#[specta::specta] // < You must annotate your commands
fn hello_world(my_name: String) -> String {
    format!("Hello, {my_name}! You\'ve been greeted from Rust!")
}

fn main() {
    let mut builder = Builder::<tauri::Wry>::new()
        // Then register them (separated by a comma)
        .commands(collect_commands![hello_world,]);

    #[cfg(debug_assertions)] // <- Only export on non-release builds
    builder
        .export(Typescript::default(), "../src/bindings.ts")
        .expect("Failed to export typescript bindings");

    tauri::Builder::default()
        // and finally tell Tauri how to invoke them
        .invoke_handler(builder.invoke_handler())
        .setup(move |app| {
            // This is also required if you want to use events
            builder.mount_events(app);

            Ok(())
        })
        // on an actual app, remove the string argument
        .run(tauri::generate_context!("tests/tauri.conf.json"))
        .expect("error while running tauri application");
}
```

--------------------------------

### Tauri Specta Setup with JSDoc Export

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

This example shows how to configure Tauri Specta to export API bindings in JSDoc format to a JavaScript file. It's suitable for integration into your `main.rs` and should be conditionally compiled using `#[cfg(debug_assertions)]`.

```rust
use tauri_specta::{collect_commands,collect_events,Builder};
use specta_jsdoc::JSDoc;


let mut builder = <Builder>::new()
    .commands(collect_commands![])
    .events(collect_events![]);

// exporting to JsDoc
#[cfg(debug_assertions)]
builder
    .export(JSDoc::default(), "../src/bindings.js")
    .expect("Failed to export jsdoc bindings");

tauri::Builder::default()
    .invoke_handler(builder.invoke_handler()) // < Required for commands to work
    .setup(move |app| {
        builder.mount_events(app); // < Required for events to work

        Ok(())
    })
    // on an actual app, remove the string argument
    .run(tauri::generate_context!("tests/tauri.conf.json"))
    .expect("error while running tauri application");

```

--------------------------------

### Mounting Events with Builder

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

This snippet demonstrates how to initialize the Builder with collected events and mount them into the Tauri application during setup. Ensure `collect_events!` macro is used correctly.

```rust
use tauri_specta::{Builder, collect_events};

let mut builder = Builder::<tauri::Wry>::new().events(collect_events![]);

tauri::Builder::default()
    .setup(move |app| {
        builder.mount_events(app);
             
        Ok(())
    })
    // on an actual app, remove the string argument
    .run(tauri::generate_context!("tests/tauri.conf.json"))
    .expect("error while running tauri application");
```

--------------------------------

### Frontend Event Handling with Specta Bindings

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/lib.rs.html

Example of how to listen to and emit Specta-generated events on the frontend using JavaScript. This demonstrates listening to events for all windows or a specific window.

```typescript
import { commands, events } from "./bindings";
import { appWindow } from "@tauri-apps/api/window";

// For all windows
events.demoEvent.listen((e) => console.log(e));

// For a single window
events.demoEvent(appWindow).listen((e) => console.log(e));

// Emit to the backend and all windows
await events.demoEvent.emit("Test")

// Emit to a window
await events.demoEvent(appWindow).emit("Test")

```

--------------------------------

### Install Tauri Specta Dependencies

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/lib.rs.html

Add these dependencies to your Cargo.toml for Tauri Specta. Use exact versions for stability.

```sh
cargo add tauri@2.0 specta@=2.0.0-rc.21

# Typescript
cargo add specta-typescript@0.0.9
cargo add tauri-specta@=2.0.0-rc.21 --features derive,typescript

# JSDoc
cargo add specta-jsdoc@0.0.9
cargo add tauri-specta@=2.0.0-rc.21 --features derive,javascript
```

--------------------------------

### Annotating Tauri Commands for Specta

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/macro.collect_commands.html

Example of how to annotate Rust functions with `#[tauri::command]` and `#[specta::specta]` to make them discoverable by `collect_commands`.

```rust
use tauri_specta::{collect_commands,Builder};

#[tauri::command]
#[specta::specta] // < You must annotate your commands
fn hello_world(my_name: String) -> String {
    format!("Hello, {my_name}! You've been greeted from Rust!")
}

#[tauri::command]
#[specta::specta] // < You must annotate your commands
fn generic_command<R: tauri::Runtime>(my_name: tauri::AppHandle<R>) -> String {
    format!("You've been greeted from a generic Rust function!")
}

mod hello {
    #[tauri::command]
    #[specta::specta] // < You must annotate your commands
    pub fn world() -> String {
        format!("Hello world")
    }
}
```

--------------------------------

### Add Tauri Specta Dependencies

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/index.html

Install Tauri v2, Specta v2, and the chosen exporter (Typescript or JSDoc) with exact versioning to prevent future breakages.

```bash
# Always required
cargo add tauri@2.0 specta@=2.0.0-rc.21

# Typescript
cargo add specta-typescript@0.0.9
cargo add tauri-specta@=2.0.0-rc.21 --features derive,typescript

# JSDoc
cargo add specta-jsdoc@0.0.9
cargo add tauri-specta@=2.0.0-rc.21 --features derive,javascript
```

--------------------------------

### Exporting Bindings to String (TypeScript)

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

This example shows how to export Specta bindings to a string format, specifically using the TypeScript language. This is useful for generating binding files programmatically.

```rust
use std::fs::File;
use std::io::Write;
use specta_typescript::Typescript;

println!(
    "{}",
    tauri_specta::Builder::<tauri::Wry>::new()
        .export_str(Typescript::new())
        .unwrap()
);
```

--------------------------------

### Typescript Implementation of LanguageExt

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/trait.LanguageExt.html

Example implementation of the LanguageExt trait for TypeScript. This enables Tauri Specta to generate TypeScript definitions.

```rust
type Error = ExportError
```

```rust
fn render(&self, cfg: &ExportContext) -> Result<String, ExportError>
```

```rust
fn format(&self, path: &Path) -> Result<(), Self::Error>
```

--------------------------------

### Typesafe Events with `specta::Event`

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/lib.rs.html

Make your Tauri events typesafe by deriving the `specta::Event` macro. This example shows how to define, collect, and emit events, and how to listen for them on the frontend.

```APIDOC
## Events

You can also make events typesafe by following the following example:

```rust
use serde::{Serialize, Deserialize};
use specta::Type;
use tauri_specta::{Builder, collect_commands, collect_events, Event};

// Add `tauri_specta::Event` to your event
#[derive(Serialize, Deserialize, Debug, Clone, Type, Event)]
pub struct DemoEvent(String);

let mut builder = Builder::<tauri::Wry>::new()
        // and then register it to your builder
        .events(collect_events![DemoEvent]);

tauri::Builder::default()
        .invoke_handler(builder.invoke_handler())
        .setup(move |app| {
            // Ensure you mount your events!
            builder.mount_events(app);

            // Now you can use them

            DemoEvent::listen(app, |event| {
                println!("{:?}", event.payload);
            });

            DemoEvent("Test".into()).emit(app).unwrap();

            Ok(())
        });
```

and it can be used on the frontend like the following:

```ts
import { commands, events } from "./bindings";
import { appWindow } from "@tauri-apps/api/window";

// For all windows
events.demoEvent.listen((e) => console.log(e));

// For a single window
events.demoEvent(appWindow).listen((e) => console.log(e));

// Emit to the backend and all windows
await events.demoEvent.emit("Test")

// Emit to a window
await events.demoEvent(appWindow).emit("Test")
```

Refer to [`Event`] for all the possible methods for listening and emitting events.
```

--------------------------------

### Install Tauri Specta Dependencies

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/index.html

Add the necessary dependencies to your Cargo.toml for Tauri Specta, including core Tauri, Specta, and the desired exporter (Typescript or JSDoc). Ensure exact version matching for stability.

```bash
# Always required
car go add tauri@2.0 specta@=2.0.0-rc.21

# Typescript
car go add specta-typescript@0.0.9
car go add tauri-specta@=2.0.0-rc.21 --features derive,typescript

# JSDoc
car go add specta-jsdoc@0.0.9
car go add tauri-specta@=2.0.0-rc.21 --features derive,javascript
```

--------------------------------

### Registering Events with Builder

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

This example shows how to register events with the Tauri Specta builder. Similar to commands, this method overwrites existing event registrations. Ensure your event struct derives `Serialize`, `Deserialize`, `Debug`, `Clone`, `Type`, and `Event`.

```rust
use serde::{Serialize, Deserialize};
use specta::Type;
use tauri_specta::{Builder, collect_events, Event};

#[derive(Serialize, Deserialize, Debug, Clone, Type, Event)]
pub struct DemoEvent(String);

let mut builder = Builder::<tauri::Wry>::new().events(collect_events![DemoEvent]);

```

--------------------------------

### JSDoc Implementation of LanguageExt

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/trait.LanguageExt.html

Example implementation of the LanguageExt trait for JSDoc. This allows Tauri Specta to generate JSDoc comments.

```rust
type Error = ExportError
```

```rust
fn render(&self, cfg: &ExportContext) -> Result<String, Self::Error>
```

```rust
fn format(&self, path: &Path) -> Result<(), Self::Error>
```

--------------------------------

### Example Usage of Event Trait

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/trait.Event.html

Demonstrates how to define a custom event struct, derive the Event trait, and use its methods for listening and emitting events within a Tauri application.

```rust
use serde::{Serialize, Deserialize};
use specta::Type;
use tauri_specta::Event;
use tauri::AppHandle;

#[derive(Debug, Clone, Serialize, Deserialize, Type, Event)]
pub struct MyEvent(String);

fn use_event(app_handle: AppHandle) {
    MyEvent::listen(&app_handle, |event| {
        dbg!(event.payload);
    });

    MyEvent("Test".to_string()).emit(&app_handle).ok();
}
```

--------------------------------

### Exporting a Constant Value with Builder

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

This example demonstrates how to export a constant value from Rust to the frontend using the `constant` method on the builder. This is useful for sharing application-wide constants or Rust-generated data.

```rust
use tauri_specta::Builder;

let mut builder = Builder::<tauri::Wry>::new().constant("CONSTANT_NAME","ANY_CONSTANT_VALUE");

```

--------------------------------

### Export Bindings to String with Tauri Specta

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/builder.rs.html

Use `export_str` to get the generated bindings as a string. This is useful when you need to manually handle the output, such as logging it or processing it further before saving.

```rust
use std::
    fs::File,
    io::Write
};
use specta_typescript::Typescript;

println!(
    "{}",
    tauri_specta::Builder::<tauri::Wry>::new()
        .export_str(Typescript::new())
        .unwrap()
);
```

--------------------------------

### Define and Use Typesafe Events in Tauri Specta

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/index.html

Define an event struct by deriving `Event` and `Type`. Register collected events with the `Builder` and mount them in your Tauri application's setup. Listen for events using `Event::listen` and emit them using `Event::emit`.

```rust
use serde::{Serialize, Deserialize};
use specta::Type;
use tauri_specta::{Builder, collect_commands, collect_events, Event};

// Add `tauri_specta::Event` to your event
#[derive(Serialize, Deserialize, Debug, Clone, Type, Event)]
pub struct DemoEvent(String);

let mut builder = Builder::<tauri::Wry>::new()
        // and then register it to your builder
        .events(collect_events![DemoEvent]);

tauri::Builder::default()
        .invoke_handler(builder.invoke_handler())
        .setup(move |app| {
            // Ensure you mount your events!
            builder.mount_events(app);

            // Now you can use them

            DemoEvent::listen(app, |event| {
                println!("{:?}", event.payload);
            });

            DemoEvent("Test".into()).emit(app).unwrap();

            Ok(())
        });
```

--------------------------------

### Builder Initialization and Event Collection

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

Demonstrates how to initialize the Builder and collect events. This is a foundational step before mounting events to a Tauri application.

```APIDOC
## Builder Initialization and Event Collection

### Description
Initializes the `Builder` and collects events. This setup is typically used within a Tauri application's `setup` hook.

### Code Example
```rust
use tauri_specta::{Builder, collect_events};

let mut builder = Builder::<tauri::Wry>::new().events(collect_events![]);

tauri::Builder::default()
    .setup(move |app| {
        builder.mount_events(app);
             
        Ok(())
    })
    .run(tauri::generate_context!("tests/tauri.conf.json"))
    .expect("error while running tauri application");
```
```

--------------------------------

### LanguageExt::format Method

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/trait.LanguageExt.html

Formats the generated bindings file at the specified path. This is useful for ensuring consistent code style.

```rust
fn format(&self, path: &Path) -> Result<(), Self::Error>
```

--------------------------------

### Builder::new

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

Constructs a new Tauri Specta builder instance.

```APIDOC
## pub fn new() -> Self

Construct a new Tauri Specta builder.
```

--------------------------------

### Using collect_commands with Tauri Builder

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/macro.collect_commands.html

Demonstrates how to use the `collect_commands` macro to pass a list of commands and modules to the Tauri `Builder`.

```rust
let mut builder = Builder::<tauri::Wry>::new()
    .commands(collect_commands![
        // You can pass a function name.
        hello_world,
        // You can also pass a module.
        hello::world,
        // Unlike `tauri::generate_handler` you may need to specify generics.
        generic_command::<tauri::Wry>
        
    ]);
```

--------------------------------

### LanguageExt::render Method

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/trait.LanguageExt.html

Renders the complete bindings file for a given language. This method is essential for generating the output code.

```rust
fn render(&self, cfg: &ExportContext) -> Result<String, Self::Error>
```

--------------------------------

### EventRegistry Implementation

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/event.rs.html

Provides methods for managing and retrieving event metadata, ensuring events are correctly registered and prefixed when used with plugins.

```rust
use std::{borrow::Cow, collections::HashMap, sync::RwLock};

use serde::{de::DeserializeOwned, Serialize};
use specta::{NamedType, SpectaID};
use tauri::{Emitter, EventId, EventTarget, Listener, Manager, Runtime};

use crate::{apply_as_prefix, ItemType};

#[derive(Default)]
pub(crate) struct EventRegistryMeta {
    pub plugin_name: Option<&'static str>,
}

/// A struct for managing events that is put into Tauri's state.
#[derive(Default)]
pub(crate) struct EventRegistry(pub(crate) RwLock<HashMap<SpectaID, EventRegistryMeta>>);

impl EventRegistry {
    /// gets the name of the event (taking into account plugin prefixes) and ensuring it was correctly mounted to the current app.
    pub fn get_event_name<E: Event, R: Runtime>(
        handle: &impl Manager<R>,
        name: &'static str,
    ) -> Cow<'static, str> {
        let this = handle.try_state::<EventRegistry>().expect(
            "EventRegistry not found in Tauri state - Did you forget to call Builder::mount_events?",
        ).inner();

        let sid = E::sid();

        let map = this.0.read().expect("Failed to read EventRegistry");
        let meta = map
            .get(&sid)
            .unwrap_or_else(|| panic!("Event {name} not found in registry!"));

        meta.plugin_name
            .map(|n| apply_as_prefix(n, name, ItemType::Event).into())
            .unwrap_or_else(|| name.into())
    }

    pub fn get_or_manage<R: Runtime>(handle: &impl Manager<R>) -> tauri::State<'_, Self> {
        if handle.try_state::<Self>().is_none() {
            handle.manage(Self::default());
        }

        handle.state::<Self>()
    }
}
```

--------------------------------

### mount_events

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/builder.rs.html

Mounts all of the events in the builder onto a Tauri app. This should be called within [`tauri::Builder::setup`](tauri::Builder::setup).

```APIDOC
## mount_events

### Description
Mounts all of the events in the builder onto a Tauri app. This should be called within [`tauri::Builder::setup`](tauri::Builder::setup).

### Method Signature
`pub fn mount_events(&self, app: &tauri::AppHandle<R>)`

### Example
```rust,no_run
use tauri_specta::{Builder, collect_events};

let mut builder = Builder::<tauri::Wry>::new().events(collect_events![]);

tauri::Builder::default()
    .setup(move |app| {
        builder.mount_events(app);
            
        Ok(())
    })
```
```

--------------------------------

### Frontend Event Handling with Tauri Specta

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/index.html

Use the generated bindings to listen for and emit events on the frontend. Events can be listened to or emitted for all windows or specific windows.

```javascript
import { commands, events } from "./bindings";
import { appWindow } from "@tauri-apps/api/window";

// For all windows
events.demoEvent.listen((e) => console.log(e));

// For a single window
events.demoEvent(appWindow).listen((e) => console.log(e));

// Emit to the backend and all windows
await events.demoEvent.emit("Test")

// Emit to a window
await events.demoEvent(appWindow).emit("Test")
```

--------------------------------

### Event Listening Methods

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/trait.Event.html

Methods for listening to events. These allow you to register callbacks that will be executed when a specific event is emitted.

```APIDOC
## fn listen<F, R: Runtime, H: Listener<R> + Manager<R>>( handle: &H, handler: F, ) -> EventId

### Description
Listen to an emitted event on this manager.

### Parameters
- **handle**: &H - The manager instance (e.g., AppHandle, Window).
- **handler**: F - The callback function to execute when the event is received.

### Type Parameters
- **F**: Fn(TypedEvent<Self>) + Send + 'static - The type of the handler function.
- **R**: Runtime - The Tauri runtime type.
- **H**: Listener<R> + Manager<R> - The type implementing both Listener and Manager traits.
- **Self**: DeserializeOwned - The event type must be deserializable.

### Returns
- EventId - An identifier for the registered listener.
```

```APIDOC
## fn listen_any<F, R: Runtime, H: Listener<R> + Manager<R>>( handle: &H, handler: F, ) -> EventId

### Description
Listen to an emitted event to any target.

### Parameters
- **handle**: &H - The manager instance.
- **handler**: F - The callback function.

### Type Parameters
- **F**: Fn(TypedEvent<Self>) + Send + 'static - The type of the handler function.
- **R**: Runtime - The Tauri runtime type.
- **H**: Listener<R> + Manager<R> - The type implementing both Listener and Manager traits.
- **Self**: DeserializeOwned - The event type must be deserializable.

### Returns
- EventId - An identifier for the registered listener.
```

```APIDOC
## fn once<F, R: Runtime, H: Listener<R> + Manager<R>>( handle: &H, handler: F, ) -> EventId

### Description
Listen to an event on this manager only once.

### Parameters
- **handle**: &H - The manager instance.
- **handler**: F - The callback function to execute once.

### Type Parameters
- **F**: FnOnce(TypedEvent<Self>) + Send + 'static - The type of the handler function.
- **R**: Runtime - The Tauri runtime type.
- **H**: Listener<R> + Manager<R> - The type implementing both Listener and Manager traits.
- **Self**: DeserializeOwned - The event type must be deserializable.

### Returns
- EventId - An identifier for the registered listener.
```

```APIDOC
## fn once_any<F, R: Runtime, H: Listener<R> + Manager<R>>( handle: &H, handler: F, ) -> EventId

### Description
Listens once to an emitted event to any target.

### Parameters
- **handle**: &H - The manager instance.
- **handler**: F - The callback function to execute once.

### Type Parameters
- **F**: FnOnce(TypedEvent<Self>) + Send + 'static - The type of the handler function.
- **R**: Runtime - The Tauri runtime type.
- **H**: Listener<R> + Manager<R> - The type implementing both Listener and Manager traits.
- **Self**: DeserializeOwned - The event type must be deserializable.

### Returns
- EventId - An identifier for the registered listener.
```

--------------------------------

### Builder::mount_events

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

Mounts all registered events from the builder onto a Tauri application instance. This method should be called within the `tauri::Builder::setup` closure.

```APIDOC
## pub fn mount_events(&self, handle: &impl Manager<R>)

Mount all of the events in the builder onto a Tauri app.
This should be called within `tauri::Builder::setup` like the example below.
```

--------------------------------

### Mount Events onto Tauri App

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/builder.rs.html

Mount all events registered with the builder onto a Tauri app. This should be called within `tauri::Builder::setup`.

```rust
use tauri_specta::{Builder, collect_events};

let mut builder = Builder::<tauri::Wry>::new().events(collect_events![]);

tauri::Builder::default()
    .setup(move |app| {
        builder.mount_events(app);
            
        Ok(())
    })
```

--------------------------------

### export

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/builder.rs.html

Exports the application bindings to a file in the specified language. This method handles directory creation and file writing, making it convenient for integrating bindings into your project.

```APIDOC
## export

### Description
Exports the application bindings to a file in the specified language. This method handles directory creation and file writing, making it convenient for integrating bindings into your project.

### Method
`export<L: LanguageExt>(&self, language: L, path: impl AsRef<Path>) -> Result<(), L::Error>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **language** (`L` where `L: LanguageExt`): The language formatter to use for exporting the bindings.
- **path** (`impl AsRef<Path>`): The file path where the bindings should be exported.

### Request Example
```rust
use tauri_specta::Builder;
use specta_typescript::Typescript;

let mut builder = Builder::<tauri::Wry>::new();

#[cfg(debug_assertions)] // only export on debug builds.
builder
    .export(Typescript::default(), "../src/bindings.ts")
    .expect("Failed to export typescript bindings");
```

### Response
#### Success Response (200)
- Returns `Ok(())` on successful export.

#### Response Example
```json
{
  "example": "// File exported successfully"
}
```
```

--------------------------------

### Exporting Bindings to File (TypeScript)

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

This snippet demonstrates exporting Specta bindings to a file, specifically for TypeScript. It collects both commands and events before exporting. The export is conditionally compiled for debug builds only.

```rust
use tauri_specta::{Builder, collect_commands, collect_events};
use specta_typescript::Typescript;

let mut builder = Builder::<tauri::Wry>::new()
    .commands(collect_commands![])
    .events(collect_events![]);

#[cfg(debug_assertions)] // only export on debug builds.
builder
    .export(Typescript::default(), "../src/bindings.ts")
    .expect("Failed to export typescript bindings");
```

--------------------------------

### Register Commands with Builder

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/builder.rs.html

Use this method to register commands with the builder. It overwrites any previously registered commands.

```rust
use tauri_specta::{Builder, collect_commands};

#[tauri::command]
#[specta::specta]
fn hello_world(my_name: String) -> String {
    format!("Hello, {my_name}! You\'ve been greeted from Rust!")
}

let mut builder = Builder::<tauri::Wry>::new().commands(collect_commands![hello_world]);
```

--------------------------------

### Render JavaScript Documentation

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/lang/js.rs.html

Implements the `LanguageExt` trait for `specta_jsdoc::JSDoc` to render documentation in JavaScript format. It handles dependent types, global constants, and renders commands and events.

```rust
use std::path::Path;

use heck::ToLowerCamelCase;
use specta::datatype::FunctionResultVariant;
use specta_typescript::{js_doc, ExportError, Typescript};

use crate::{ExportContext, LanguageExt};

use super::js_ts;

const GLOBALS: &str = include_str!("./globals.js");

impl LanguageExt for specta_jsdoc::JSDoc {
    type Error = ExportError;

    fn render(&self, cfg: &ExportContext) -> Result<String, Self::Error> {
        let dependant_types = cfg
            .type_map
            .into_iter()
            .map(|(_sid, ndt)| js_doc::typedef_named_datatype(&self.0, ndt, &cfg.type_map))
            .collect::<Result<Vec<_>, _>>()
            .map(|v| v.join("\n"))?;

        js_ts::render_all_parts::<Self>(
            cfg,
            &dependant_types,
            GLOBALS,
            &self.0.header,
            render_commands(&self.0, cfg)?,
            render_events(&self.0, cfg)?,
            false,
        )
    }

    fn format(&self, path: &Path) -> Result<(), Self::Error> {
        if let Some(formatter) = self.0.formatter {
            formatter(path)?;
        }
        Ok(())
    }
}
```

--------------------------------

### Apply Prefix to Item Name

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/lib.rs.html

Constructs a prefixed string for commands or events, used internally for naming conventions.

```rust
pub(crate) fn apply_as_prefix(plugin_name: &str, s: &str, item_type: ItemType) -> String {
    format!(
        "plugin:{}{}{}",
        plugin_name,
        match item_type {
            ItemType::Event => ":",
            ItemType::Command => "|",
        },
        s,
    )
}
```

--------------------------------

### Exporting to JSDoc

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/lib.rs.html

To use JSDoc instead of Typescript, replace `specta_typescript::Typescript` with `specta_jsdoc::JSDoc` when exporting.

```rust
let mut builder = tauri_specta::Builder::<tauri::Wry>::new();

#[cfg(debug_assertions)]
builder
    .export(specta_jsdoc::JSDoc::default(), "../src/bindings.js")
    .expect("Failed to export typescript bindings");

```

--------------------------------

### Registering Commands with Builder

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

Use this snippet to register commands with the Tauri Specta builder. This method will overwrite any previously registered commands. Ensure your command function is annotated with `#[tauri::command]` and `#[specta::specta]`.

```rust
use tauri_specta::{Builder, collect_commands};

#[tauri::command]
#[specta::specta]
fn hello_world(my_name: String) -> String {
    format!("Hello, {my_name}! You've been greeted from Rust!")
}

let mut builder = Builder::<tauri::Wry>::new().commands(collect_commands![hello_world]);

```

--------------------------------

### Generic Reference Implementation of LanguageExt

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/trait.LanguageExt.html

A generic implementation of LanguageExt for references to other LanguageExt implementors. This allows using references to language exporters.

```rust
type Error = <L as LanguageExt>::Error
```

```rust
fn render(&self, cfg: &ExportContext) -> Result<String, Self::Error>
```

```rust
fn format(&self, path: &Path) -> Result<(), Self::Error>
```

--------------------------------

### commands

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/builder.rs.html

Registers commands with the builder. WARNING: This method will overwrite any previously registered commands.

```APIDOC
## commands

### Description
Registers commands with the builder. This method will overwrite any previously registered commands.

### Method Signature
`pub fn commands(mut self, commands: Commands<R>) -> Self`

### Example
```rust
use tauri_specta::{Builder, collect_commands};

#[tauri::command]
#[specta::specta]
fn hello_world(my_name: String) -> String {
    format!("Hello, {my_name}! You\'ve been greeted from Rust!")
}

let mut builder = Builder::<tauri::Wry>::new().commands(collect_commands![hello_world]);
```
```

--------------------------------

### collect_commands!

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/macros.rs.html

Collects Tauri commands and their Specta types, returning a `Commands` struct compatible with `tauri_specta::Builder::commands`. This macro combines Tauri's `generate_handler` and Specta's `collect_functions`.

```APIDOC
## collect_commands!

### Description
Collects commands and their types. This is a combination of Tauri's [`generate_handler`](tauri::generate_handler) and Specta's [`collect_functions`](specta::function), returning a [`Commands`](crate::Commands) struct that can be passed to [`Builder::commands`](crate::Builder::commands).

### Usage
```rust
use tauri_specta::{collect_commands,Builder};

#[tauri::command]
#[specta::specta] // < You must annotate your commands
fn hello_world(my_name: String) -> String {
    format!("Hello, {my_name}! You've been greeted from Rust!")
}

#[tauri::command]
#[specta::specta] // < You must annotate your commands
fn generic_command<R: tauri::Runtime>(my_name: tauri::AppHandle<R>) -> String {
    format!("You've been greeted from a generic Rust function!")
}

mod hello {
    #[tauri::command]
    #[specta::specta] // < You must annotate your commands
    pub fn world() -> String {
        format!("Hello world")
    }
}

let mut builder = Builder::<tauri::Wry>::new()
    .commands(collect_commands![
        // You can pass a function name.
        hello_world,
        // You can also pass a module.
        hello::world,
        // Unlike `tauri::generate_handler` you may need to specify generics.
        generic_command::<tauri::Wry>
       
    ]);
```
```

--------------------------------

### Export Bindings to File

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

Exports the collected bindings to a specified file path. This is the recommended method for generating binding files, such as TypeScript definitions.

```APIDOC
## Export Bindings to File

### Description
Exports the bindings to a file at the specified path. This method is suitable for generating static binding files.

### Method Signature
`pub fn export<L: LanguageExt>(&self, language: L, path: impl AsRef<Path>) -> Result<(), L::Error>`

### Example
```rust
use tauri_specta::{Builder, collect_commands, collect_events};
use specta_typescript::Typescript;

let mut builder = Builder::<tauri::Wry>::new()
    .commands(collect_commands![])
    .events(collect_events![]);

#[cfg(debug_assertions)] // only export on debug builds.
builder
    .export(Typescript::default(), "../src/bindings.ts")
    .expect("Failed to export typescript bindings");
```
```

--------------------------------

### Export to JSDoc

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/index.html

Replace `specta_typescript::Typescript` with `specta_jsdoc::JSDoc` to export bindings in JSDoc format instead of Typescript.

```rust
let mut builder = tauri_specta::Builder::<tauri::Wry>::new();

#[cfg(debug_assertions)]
builder
    .export(specta_jsdoc::JSDoc::default(), "../src/bindings.js")
    .expect("Failed to export typescript bindings");
```

--------------------------------

### Builder::typ

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

Exports a new type with the frontend, useful for types not directly used in commands or events.

```APIDOC
## pub fn typ<T: NamedType>(self) -> Self

Export a new type with the frontend.
This is useful if you want to export types that do not appear in any events or commands.
##### §Example
```
use tauri_specta::Builder;
use serde::{Serialize, Deserialize};
use specta::Type;

#[derive(Serialize, Deserialize, Type)]
pub struct MyStruct {
    a: String
}

let mut builder = Builder::<tauri::Wry>::new().typ::<MyStruct>();
```
```

--------------------------------

### Builder::ty (Deprecated)

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

Deprecated method for exporting a type. Use `Self::typ` instead.

```APIDOC
## pub fn ty<T: NamedType>(self) -> Self

👎Deprecated: Use `Self::typ` instead
This method is deprecated. Please use Self::typ.
```

--------------------------------

### Listen once to any emitted event

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/event.rs.html

This function allows listening for an event once, regardless of the target. It's useful for reacting to the first occurrence of an event across the application.

```rust
fn once_any<F, R: Runtime, H: Listener<R> + Manager<R>>(handle: &H, handler: F) -> EventId
where
    F: FnOnce(TypedEvent<Self>) + Send + 'static,
    Self: DeserializeOwned,
{
    handle.once_any(
        EventRegistry::get_event_name::<Self, _>(handle, Self::NAME),
        make_handler!(handler),
    )
}
```

--------------------------------

### Event Emitting Methods

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/trait.Event.html

Methods for emitting events. These allow you to send events from the backend to the frontend or other parts of the application.

```APIDOC
## fn emit<R: Runtime, H: Emitter<R> + Manager<R>>(&self, handle: &H) -> Result<()>

### Description
Emits an event to all targets.

### Parameters
- **handle**: &H - The manager instance.

### Type Parameters
- **R**: Runtime - The Tauri runtime type.
- **H**: Emitter<R> + Manager<R> - The type implementing both Emitter and Manager traits.
- **Self**: Serialize + Clone - The event type must be serializable and cloneable.

### Returns
- Result<()> - Ok(()) if the event was emitted successfully, otherwise an Err.
```

```APIDOC
## fn emit_to<R: Runtime, H: Emitter<R> + Manager<R>, I: Into<EventTarget>>( &self, handle: &H, target: I, ) -> Result<()>

### Description
Emits an event to all targets matching the given target.

### Parameters
- **handle**: &H - The manager instance.
- **target**: I - The target to emit the event to.

### Type Parameters
- **R**: Runtime - The Tauri runtime type.
- **H**: Emitter<R> + Manager<R> - The type implementing both Emitter and Manager traits.
- **I**: Into<EventTarget> - The type that can be converted into an EventTarget.
- **Self**: Serialize + Clone - The event type must be serializable and cloneable.

### Returns
- Result<()> - Ok(()) if the event was emitted successfully, otherwise an Err.
```

```APIDOC
## fn emit_filter<F, R: Runtime, H: Emitter<R> + Manager<R>>( &self, handle: &H, filter: F, ) -> Result<()>

### Description
Emits an event to all targets based on the given filter.

### Parameters
- **handle**: &H - The manager instance.
- **filter**: F - A closure that returns true for targets that should receive the event.

### Type Parameters
- **F**: Fn(&EventTarget) -> bool - The type of the filter closure.
- **R**: Runtime - The Tauri runtime type.
- **H**: Emitter<R> + Manager<R> - The type implementing both Emitter and Manager traits.
- **Self**: Serialize + Clone - The event type must be serializable and cloneable.

### Returns
- Result<()> - Ok(()) if the event was emitted successfully, otherwise an Err.
```

--------------------------------

### Into Implementation for Events

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Events.html

Allows converting a type T into another type U, provided that U implements From<T>. This is a standard blanket implementation.

```rust
fn into(self) -> U
```

--------------------------------

### Register Events with Builder

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/builder.rs.html

Use this method to register events with the builder. It overwrites any previously registered events.

```rust
use serde::{Serialize, Deserialize};
use specta::Type;
use tauri_specta::{Builder, collect_events, Event};

#[derive(Serialize, Deserialize, Debug, Clone, Type, Event)]
pub struct DemoEvent(String);

let mut builder = Builder::<tauri::Wry>::new().events(collect_events![DemoEvent]);
```

--------------------------------

### EventRegistry

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/event.rs.html

The `EventRegistry` is a Tauri state that manages event metadata, ensuring events are correctly mounted and their names are properly prefixed when used with plugins.

```APIDOC
## EventRegistry

### Description

A struct for managing events that is put into Tauri's state. It ensures events are correctly mounted and handles plugin prefixes.

### Methods

- `get_event_name<E: Event, R: Runtime>(handle: &impl Manager<R>, name: &'static str) -> Cow<'static, str>`
  - Gets the event name, applying plugin prefixes if necessary.
  - Panics if `EventRegistry` is not found in Tauri state or if the event is not registered.

- `get_or_manage<R: Runtime>(handle: &impl Manager<R>) -> tauri::State<'_, Self>`
  - Retrieves the `EventRegistry` from Tauri's state, managing its creation if it doesn't exist.

```

--------------------------------

### typ

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/builder.rs.html

Exports a new type with the frontend. This is useful if you want to export types that do not appear in any events or commands.

```APIDOC
## typ

### Description
Exports a new type with the frontend. This is useful if you want to export types that do not appear in any events or commands.

### Method Signature
`pub fn typ<T: NamedType>(mut self) -> Self`

### Example
```rust
use tauri_specta::Builder;
use serde::{Serialize, Deserialize};
use specta::Type;

#[derive(Serialize, Deserialize, Type)]
pub struct MyStruct {
    a: String
}

let mut builder = Builder::<tauri::Wry>::new().typ::<MyStruct>();
```
```

--------------------------------

### Generate TypeScript Event Map

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/lang/js_ts.rs.html

Creates a mapping of event names to their string representations, applying a plugin prefix if provided. Useful for defining event listeners in TypeScript.

```rust
pub fn events_map(
    events: &BTreeMap<&'static str, DataType>,
    plugin_name: &Option<&'static str>,
) -> String {
    events
        .iter()
        .map(|(name, _)| {
            let name_str = plugin_name
                .as_ref() 
                .map(|n| apply_as_prefix(n, name, ItemType::Event))
                .unwrap_or_else(|| name.to_string());
            let name_camel = name.to_lower_camel_case();

            format!(r#"{name_camel}: \"{name_str}\""#)
        })
        .collect::<Vec<_>>()
        .join(",\n")
}
```

--------------------------------

### export_str

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/src/tauri_specta/builder.rs.html

Exports the application bindings to a string representation for a specified language. This is useful when you need direct control over how the bindings are processed or displayed.

```APIDOC
## export_str

### Description
Exports the application bindings to a string representation for a specified language. This is useful when you need direct control over how the bindings are processed or displayed.

### Method
`export_str<L: LanguageExt>(&self, language: L) -> Result<String, L::Error>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
use specta_typescript::Typescript;

let builder = tauri_specta::Builder::<tauri::Wry>::new();
let exported_string = builder.export_str(Typescript::new()).unwrap();
println!("{}", exported_string);
```

### Response
#### Success Response (String)
- Returns a `String` containing the exported bindings in the format specified by the `language` parameter.

#### Response Example
```json
{
  "example": "// Exported bindings as a string"
}
```
```

--------------------------------

### Builder::plugin_name

Source: https://docs.rs/tauri-specta/2.0.0-rc.21/tauri_specta/struct.Builder.html

Sets the name of the current plugin. This is crucial for ensuring generated bindings correctly reference the plugin.

```APIDOC
## pub fn plugin_name(self, plugin_name: &'static str) -> Self

Set the name of the current plugin name.
This is used to ensure the generated bindings correctly reference the plugin.
```
Tokens:
Raw