> ## Documentation Index
> Fetch the complete documentation index at: https://abxbus.archivebox.io/llms.txt
> Use this file to discover all available pages before exploring further.

# EventHandler

> EventHandler metadata and registration records.

`EventHandler` is the serializable metadata record for a registered handler function.

You receive handler entries from `bus.on(...)`, can remove them with `bus.off(...)`, and see them in handler-change middleware/hooks.

## Common fields

* `id`: stable handler id
* `handler_name`: callable/function name
* `handler_file_path`: source path metadata (`str | None` in Python, `string | null` in TypeScript)
* `handler_timeout`: optional per-handler timeout override
* `handler_slow_timeout`: optional slow-warning override
* `handler_registered_at`
* `event_pattern`: subscribed key (`EventType` or `'*'`)
* `eventbus_name`, `eventbus_id`

## `bus.on(...)` and `bus.off(...)`

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    entry = bus.on(MyEvent, handler)
    bus.off(MyEvent, entry)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```ts theme={null}
    const entry = bus.on(MyEvent, handler)
    bus.off(MyEvent, entry)
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    type MyEvent struct{}

    handler := func(event MyEvent) {}
    entry := bus.On(handler)
    bus.Off("MyEvent", entry)
    ```
  </Tab>

  <Tab title="Rust">
    ```rust theme={null}
    use abxbus::{event, event_bus::EventBus};
    use abxbus::typed::EventSpec;

    event! {
        struct MyEvent {
            event_result_type: serde_json::Value,
        }
    }

    let bus = EventBus::new(Some("HandlerBus".to_string()));
    let entry = bus.on(MyEvent, |_event: MyEvent| async move {
        Ok(serde_json::Value::Null)
    });
    bus.off(MyEvent::event_type, Some(&entry.id));
    ```
  </Tab>
</Tabs>

## Serialization

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    payload = entry.model_dump(mode='json', exclude={'handler'})
    print(payload)
    # {
    #   "id": "018f...",
    #   "handler_name": "app.handlers.on_user_created",
    #   "event_pattern": "UserCreatedEvent",
    #   "eventbus_name": "AuthBus",
    #   "eventbus_id": "018f...",
    #   "...": "..."
    # }

    restored = EventHandler.from_json_dict(payload, handler=real_handler)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```ts theme={null}
    const payload = entry.toJSON()
    console.log(payload)
    // {
    //   id: '018f...',
    //   handler_name: 'onUserCreated',
    //   event_pattern: 'UserCreatedEvent',
    //   eventbus_name: 'AuthBus',
    //   eventbus_id: '018f...',
    //   ...
    // }

    const restored = EventHandler.fromJSON(payload, realHandler)
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    payload, err := entry.ToJSON()
    fmt.Println(string(payload))
    // {
    //   "id": "018f...",
    //   "handler_name": "on_user_created",
    //   "event_pattern": "UserCreatedEvent",
    //   "eventbus_name": "AuthBus",
    //   "eventbus_id": "018f...",
    //   ...
    // }

    restored, err := abxbus.EventHandlerFromJSON(payload, realHandler)
    ```
  </Tab>

  <Tab title="Rust">
    ```rust theme={null}
    let payload = entry.to_json_value();
    println!("{}", serde_json::to_string_pretty(&payload)?);
    // {
    //   "id": "018f...",
    //   "handler_name": "on_user_created",
    //   "event_pattern": "UserCreatedEvent",
    //   "eventbus_name": "AuthBus",
    //   "eventbus_id": "018f...",
    //   ...
    // }

    let restored = abxbus::event_handler::EventHandler::from_json_value(payload);
    ```
  </Tab>
</Tabs>

## Notes

* Function bodies are not serialized.
* Rehydration restores metadata; execution behavior requires re-binding a real callable.