// Define an interface
class IWidget : public Interface<IWidget> {
public:
    VELK_INTERFACE(
        (PROP, float, width, 100.f),
        (EVT, on_clicked),
        (FN, void, reset)
    )
};

// Implement, register, create, use
class Widget : public ext::Object<Widget, IWidget> {
    void fn_reset() override { width().set_value(0.f); }
};

// Register type
auto& instance = velk::instance();
instance.type_registry().register_type<Widget>();

// Instantiate and use
auto w = instance.create<IWidget>(Widget::static_class_id());
w->width().set_value(42.f);
w->width().on_changed().add_handler([](){ /*...*/ });
w->on_clicked().add_handler([]() { /*...*/ });
velk::invoke_function(w->reset());

#include <interface/intf_metadata.h>

class IMyWidget : public Interface<IMyWidget>
{
public:
    // Static interface metadata:
    VELK_INTERFACE(
        (PROP, float, width, 100.f),                // Read-write float property, default value 100.f
        (PROP, float, height, 100.f),
        (RPROP, int, id, 0),                        // Read-only int property, default value 0
        (ARR, uint32_t, layers, 1u, 2u, 3u),        // Array uint32_t property (array of values), default value {1u, 2u, 3u}
        (EVT, on_clicked),                          // Event
        (FN, void, reset),                          // Function without arguments
        (FN, void, resize, (float, w), (float, h))  // Function with 2 arguments
    )

    // Regular pure virtual function, part of the interface but not metadata.
    virtual void paint() = 0; 
};

#include <velk/ext/object.h>

class MyWidget : public ext::Object<MyWidget, IMyWidget>
{
    // Implementations of the IMyWidget static metadata-defined functions "reset" and "resize"
    void fn_reset() override {
    }
    void fn_resize(float w, float h) override {
        width().set_value(w);   // width property as defined in VELK_INTERFACE
        height().set_value(h);
    }

    // Implementation of the pure virtual non-metadata function defined in IMyWidget
    void paint() override {}
};

class ISerializable : public Interface<ISerializable>
{
public:
    VELK_INTERFACE(
        (PROP, velk::string, name, ""),
        (FN, void, serialize)
    )
};

class MyWidget : public ext::Object<MyWidget, IMyWidget, ISerializable>
{
    // Implementations for the functions defined in IMyWidget and ISerializable static metadata
    void fn_reset() override { /* ... */ }                  // zero-arg
    void fn_resize(float w, float h) override { /* ... */ } // typed args
    void fn_serialize() override { /* ... */ }              // from ISerializable

    // Non-metadata paint() from IMyWidget
    void paint() override {}
};

auto& s = instance();                                           // global IVelk
s.type_registry().register_type<MyWidget>();                    // register factory

auto widget = s.create<IObject>(MyWidget::static_class_id());     // create by UID

auto widget = s.create<IMyWidget>(MyWidget::static_class_id());
if (widget) {
    auto wp = iw->width();
    wp.set_value(42.f);                                         // set property
    float w = wp.get_value();                                   // read property

    Event clicked = iw->on_clicked();                           // get event handle
    clicked.add_handler([]() { std::cout << "clicked"; });      // add event handler
    Function reset = iw->reset().invoke();                      // get function handle
}

if (auto* info = instance().type_registry().get_class_info(MyWidget::static_class_id())) {  // lookup by UID
    for (auto& i : info->interfaces) {                             // enumerate interfaces
        // i.uid, i.name
    }
    for (auto& m : info->members) {                                // enumerate members
        // m.name, m.kind, m.interfaceInfo
    }
}

auto widget = s.create(MyWidget::static_class_id());
if (auto* meta = interface_cast<IMetadata>(widget)) {           // query interface for runtime introspection
    auto prop  = meta->get_property("width");                   // lookup by name
    auto event = meta->get_event("on_clicked");                 // lookup by name
    auto func  = meta->get_function("reset");                   // lookup by name
}

auto widget = s.create<IObject>(MyWidget::static_class_id());
auto* iw = interface_cast<IMyWidget>(widget);

// Read state directly
if (auto reader = read_state<IMyWidget>(iw)) {
    float w = reader->width;                                    // 100.f (default)
}

// Write state, fires on_changed for instantiated properties when writer goes out of scope
if (auto writer = write_state<IMyWidget>(iw)) {
    // struct IMyWidget::State {                                 // generated by VELK_INTERFACE
    //   float width { 100.f };
    //   float height { 100.f };
    //   int id { 0 };
    //   velk::vector<uint32_t> layers { 1u, 2u, 3u };
    // }
    writer->width = 200.f;
    writer->height = 50.f;
    writer->layers.push_back(4u);
}                                                               // ~StateWriter notifies listeners

iw->width().get_value();                                        // 200.f