@open-core/framework 1.0.5-beta.1 → 1.0.5-beta.2

package/dist/runtime/client/system/processors/interval.processor.js

@@ -4,18 +4,29 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { injectable } from 'tsyringe';
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
 import { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
 import { METADATA_KEYS } from '../metadata-client.keys';
 const clientInterval = coreLogger.child('Interval', LogDomain.CLIENT);
 let IntervalProcessor = class IntervalProcessor {
+    runtime;
     metadataKey = METADATA_KEYS.INTERVAL;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
     process(target, methodName, metadata) {
         const handler = target[methodName].bind(target);
         const handlerName = `${target.constructor.name}.${methodName}`;
         let lastRun = 0;
-        setTick(async () => {
-            const now = GetGameTimer();
+        this.runtime.setTick(async () => {
+            const now = this.runtime.getGameTimer();
             if (now - lastRun < metadata.interval)
                 return;
             lastRun = now;
@@ -33,6 +44,8 @@ let IntervalProcessor = class IntervalProcessor {
     }
 };
 IntervalProcessor = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientRuntimeBridge])
 ], IntervalProcessor);
 export { IntervalProcessor };

package/dist/runtime/client/system/processors/key.processor.d.ts

@@ -1,6 +1,9 @@
 import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
 export declare class KeyMappingProcessor implements DecoratorProcessor {
+    private readonly runtime;
     readonly metadataKey: string;
+    constructor(runtime: IClientRuntimeBridge);
     process(target: any, methodName: string, metadata: {
         key: string;
         description?: string;

package/dist/runtime/client/system/processors/key.processor.js

@@ -4,19 +4,32 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { injectable } from 'tsyringe';
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
 import { METADATA_KEYS } from '../metadata-client.keys';
 let KeyMappingProcessor = class KeyMappingProcessor {
+    runtime;
     metadataKey = METADATA_KEYS.KEY;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
     process(target, methodName, metadata) {
         const handler = target[methodName].bind(target);
         const commandName = `+${methodName}`;
-        RegisterCommand(commandName, handler, false);
-        RegisterKeyMapping(commandName, metadata.description ?? 'none', 'keyboard', metadata.key);
-        RegisterCommand(`-${methodName}`, () => { }, false);
+        this.runtime.registerCommand(commandName, handler, false);
+        this.runtime.registerKeyMapping(commandName, metadata.description ?? 'none', 'keyboard', metadata.key);
+        this.runtime.registerCommand(`-${methodName}`, () => { }, false);
     }
 };
 KeyMappingProcessor = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientRuntimeBridge])
 ], KeyMappingProcessor);
 export { KeyMappingProcessor };

package/dist/runtime/client/system/processors/localEvent.processor.d.ts

@@ -1,6 +1,9 @@
 import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
 export declare class LocalEventProcessor implements DecoratorProcessor {
+    private readonly runtime;
     readonly metadataKey: string;
+    constructor(runtime: IClientRuntimeBridge);
     process(target: any, methodName: string, metadata: {
         eventName: string;
     }): void;

package/dist/runtime/client/system/processors/localEvent.processor.js

@@ -4,16 +4,27 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { injectable } from 'tsyringe';
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
 import { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
 import { METADATA_KEYS } from '../metadata-client.keys';
 const clientLocalEvent = coreLogger.child('LocalEvent', LogDomain.CLIENT);
 let LocalEventProcessor = class LocalEventProcessor {
+    runtime;
     metadataKey = METADATA_KEYS.LOCAL_EVENT;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
     process(target, methodName, metadata) {
         const handler = target[methodName].bind(target);
         const handlerName = `${target.constructor.name}.${methodName}`;
-        on(metadata.eventName, async (...args) => {
+        this.runtime.on(metadata.eventName, async (...args) => {
             try {
                 await handler(...args);
             }
@@ -28,6 +39,8 @@ let LocalEventProcessor = class LocalEventProcessor {
     }
 };
 LocalEventProcessor = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientRuntimeBridge])
 ], LocalEventProcessor);
 export { LocalEventProcessor };

package/dist/runtime/client/system/processors/netEvent.processor.d.ts

@@ -1,6 +1,9 @@
 import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import { EventsAPI } from '../../../../adapters/contracts/transport/events.api';
 export declare class ClientNetEventProcessor implements DecoratorProcessor {
+    private readonly events;
     readonly metadataKey: string;
+    constructor(events: EventsAPI<'client'>);
     process(target: any, methodName: string, metadata: {
         eventName: string;
     }): void;

package/dist/runtime/client/system/processors/netEvent.processor.js

@@ -4,16 +4,27 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { injectable } from 'tsyringe';
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { EventsAPI } from '../../../../adapters/contracts/transport/events.api';
 import { coreLogger, LogDomain } from '../../../../kernel/logger';
 import { METADATA_KEYS } from '../metadata-client.keys';
 const clientNetEvent = coreLogger.child('NetEvent', LogDomain.CLIENT);
 let ClientNetEventProcessor = class ClientNetEventProcessor {
+    events;
     metadataKey = METADATA_KEYS.NET_EVENT;
+    constructor(events) {
+        this.events = events;
+    }
     process(target, methodName, metadata) {
         const handler = target[methodName].bind(target);
         const handlerName = `${target.constructor.name}.${methodName}`;
-        onNet(metadata.eventName, async (...args) => {
+        this.events.on(metadata.eventName, async (_ctx, ...args) => {
             try {
                 await handler(...args);
             }
@@ -28,6 +39,8 @@ let ClientNetEventProcessor = class ClientNetEventProcessor {
     }
 };
 ClientNetEventProcessor = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(EventsAPI)),
+    __metadata("design:paramtypes", [EventsAPI])
 ], ClientNetEventProcessor);
 export { ClientNetEventProcessor };

package/dist/runtime/client/system/processors/onRpc.processor.js

@@ -14,7 +14,7 @@ import { inject, injectable } from 'tsyringe';
 import z from 'zod';
 import { RpcAPI } from '../../../../adapters/contracts/transport/rpc.api';
 import { coreLogger, LogDomain } from '../../../../kernel/logger';
-import { processTupleSchema } from '../../../server/helpers/process-tuple-schema';
+import { processTupleSchema } from '../../../shared/helpers/process-tuple-schema';
 import { METADATA_KEYS } from '../metadata-client.keys';
 const clientRpcLogger = coreLogger.child('Rpc', LogDomain.CLIENT);
 let ClientOnRpcProcessor = class ClientOnRpcProcessor {

package/dist/runtime/client/system/processors/resourceLifecycle.processor.d.ts

@@ -1,9 +1,14 @@
 import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
 export declare class ResourceStartProcessor implements DecoratorProcessor {
+    private readonly runtime;
     readonly metadataKey: string;
+    constructor(runtime: IClientRuntimeBridge);
     process(target: any, methodName: string): void;
 }
 export declare class ResourceStopProcessor implements DecoratorProcessor {
+    private readonly runtime;
     readonly metadataKey: string;
+    constructor(runtime: IClientRuntimeBridge);
     process(target: any, methodName: string): void;
 }

package/dist/runtime/client/system/processors/resourceLifecycle.processor.js

@@ -4,17 +4,28 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { injectable } from 'tsyringe';
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
 import { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
 import { METADATA_KEYS } from '../metadata-client.keys';
 const clientLifecycle = coreLogger.child('Lifecycle', LogDomain.CLIENT);
 let ResourceStartProcessor = class ResourceStartProcessor {
+    runtime;
     metadataKey = METADATA_KEYS.RESOURCE_START;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
     process(target, methodName) {
         const handler = target[methodName].bind(target);
         const handlerName = `${target.constructor.name}.${methodName}`;
-        const currentResource = GetCurrentResourceName();
-        on('onClientResourceStart', async (resourceName) => {
+        const currentResource = this.runtime.getCurrentResourceName();
+        this.runtime.on('onClientResourceStart', async (resourceName) => {
             if (resourceName !== currentResource)
                 return;
             try {
@@ -31,16 +42,22 @@ let ResourceStartProcessor = class ResourceStartProcessor {
     }
 };
 ResourceStartProcessor = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientRuntimeBridge])
 ], ResourceStartProcessor);
 export { ResourceStartProcessor };
 let ResourceStopProcessor = class ResourceStopProcessor {
+    runtime;
     metadataKey = METADATA_KEYS.RESOURCE_STOP;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
     process(target, methodName) {
         const handler = target[methodName].bind(target);
         const handlerName = `${target.constructor.name}.${methodName}`;
-        const currentResource = GetCurrentResourceName();
-        on('onClientResourceStop', async (resourceName) => {
+        const currentResource = this.runtime.getCurrentResourceName();
+        this.runtime.on('onClientResourceStop', async (resourceName) => {
             if (resourceName !== currentResource)
                 return;
             try {
@@ -57,6 +74,8 @@ let ResourceStopProcessor = class ResourceStopProcessor {
     }
 };
 ResourceStopProcessor = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientRuntimeBridge])
 ], ResourceStopProcessor);
 export { ResourceStopProcessor };

package/dist/runtime/client/system/processors/tick.processor.d.ts

@@ -1,5 +1,8 @@
 import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
 export declare class TickProcessor implements DecoratorProcessor {
+    private readonly runtime;
     readonly metadataKey: string;
+    constructor(runtime: IClientRuntimeBridge);
     process(target: any, methodName: string): void;
 }

package/dist/runtime/client/system/processors/tick.processor.js

@@ -4,16 +4,27 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { injectable } from 'tsyringe';
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
 import { coreLogger, LogDomain } from '../../../../kernel/logger';
+import { IClientRuntimeBridge } from '../../adapter/runtime-bridge';
 import { METADATA_KEYS } from '../metadata-client.keys';
 const clientTick = coreLogger.child('Tick', LogDomain.CLIENT);
 let TickProcessor = class TickProcessor {
+    runtime;
     metadataKey = METADATA_KEYS.TICK;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
     process(target, methodName) {
         const handler = target[methodName].bind(target);
         const handlerName = `${target.constructor.name}.${methodName}`;
-        setTick(async () => {
+        this.runtime.setTick(async () => {
             try {
                 await handler();
             }
@@ -27,6 +38,8 @@ let TickProcessor = class TickProcessor {
     }
 };
 TickProcessor = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(IClientRuntimeBridge)),
+    __metadata("design:paramtypes", [IClientRuntimeBridge])
 ], TickProcessor);
 export { TickProcessor };

package/dist/runtime/client/system/processors/view.processor.d.ts

@@ -1,6 +1,9 @@
 import { DecoratorProcessor } from '../../../../kernel/di/decorator-processor';
+import { WebViewService } from '../../webview.service';
 export declare class ViewProcessor implements DecoratorProcessor {
+    private readonly webviews;
     readonly metadataKey: string;
+    constructor(webviews: WebViewService);
     process(target: any, methodName: string, metadata: {
         eventName: string;
     }): void;

package/dist/runtime/client/system/processors/view.processor.js

@@ -4,33 +4,44 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { injectable } from 'tsyringe';
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
 import { loggers } from '../../../../kernel/logger';
+import { WebViewService } from '../../webview.service';
 import { METADATA_KEYS } from '../metadata-client.keys';
 let ViewProcessor = class ViewProcessor {
+    webviews;
     metadataKey = METADATA_KEYS.VIEW;
+    constructor(webviews) {
+        this.webviews = webviews;
+    }
     process(target, methodName, metadata) {
         const handler = target[methodName].bind(target);
         const handlerName = `${target.constructor.name}.${methodName}`;
-        RegisterNuiCallbackType(metadata.eventName);
-        on(`__cfx_nui:${metadata.eventName}`, async (data, cb) => {
+        this.webviews.onMessage(async (message) => {
+            if (message.event !== metadata.eventName)
+                return;
             try {
-                const result = await handler(data);
-                cb({ ok: true, data: result });
+                await handler(message.payload);
             }
             catch (error) {
-                loggers.nui.error(`NUI callback error`, {
+                loggers.webView.error(`WebView callback error`, {
                     event: metadata.eventName,
                     handler: handlerName,
                 }, error);
-                const message = error instanceof Error ? error.message : String(error);
-                cb({ ok: false, error: message });
             }
         });
-        loggers.nui.debug(`Registered: ${metadata.eventName} -> ${handlerName}`);
+        loggers.webView.debug(`Registered WebView callback: ${metadata.eventName} -> ${handlerName}`);
     }
 };
 ViewProcessor = __decorate([
-    injectable()
+    injectable(),
+    __param(0, inject(WebViewService)),
+    __metadata("design:paramtypes", [WebViewService])
 ], ViewProcessor);
 export { ViewProcessor };

package/dist/runtime/client/system/processors.register.d.ts

@@ -1 +1,2 @@
 export declare function registerSystemClient(): void;
+export declare function __resetClientProcessorRegistrationForTests(): void;

package/dist/runtime/client/system/processors.register.js

@@ -10,7 +10,11 @@ import { ClientOnRpcProcessor } from './processors/onRpc.processor';
 import { ViewProcessor } from './processors/view.processor';
 import { ResourceStartProcessor, ResourceStopProcessor, } from './processors/resourceLifecycle.processor';
 import { TickProcessor } from './processors/tick.processor';
+let processorsRegistered = false;
 export function registerSystemClient() {
+    if (processorsRegistered) {
+        return;
+    }
     // Core processors
     di.register('DecoratorProcessor', { useClass: KeyMappingProcessor });
     di.register('DecoratorProcessor', { useClass: TickProcessor });
@@ -25,4 +29,8 @@ export function registerSystemClient() {
     di.register('DecoratorProcessor', { useClass: ResourceStartProcessor });
     di.register('DecoratorProcessor', { useClass: ResourceStopProcessor });
     di.register('DecoratorProcessor', { useClass: GameEventProcessor });
+    processorsRegistered = true;
+}
+export function __resetClientProcessorRegistrationForTests() {
+    processorsRegistered = false;
 }

package/dist/runtime/client/ui-bridge.d.ts

@@ -1,116 +1,4 @@
 /**
- * Type-safe NUI (Native UI) Bridge for client-server communication.
- *
- * Generic types allow for full type safety when sending/receiving messages.
- * Define your event maps and pass them as type parameters.
- *
- * @example
- * ```typescript
- * interface ClientToUI {
- *   'showMenu': { items: string[] }
- *   'hideMenu': void
- * }
- *
- * interface UIToClient {
- *   'menuItemSelected': { index: number }
- *   'menuClosed': void
- * }
- *
- * const nui = new NuiBridge<ClientToUI, UIToClient>()
- * nui.send('showMenu', { items: ['Option 1', 'Option 2'] })
- * nui.on('menuItemSelected', async (data) => console.log(data.index))
- * ```
+ * @deprecated Import from `./webview-bridge` instead.
  */
-export declare class NuiBridge<TSend extends Record<string, any> = Record<string, any>, TReceive extends Record<string, any> = Record<string, any>> {
-    private _isVisible;
-    private _hasFocus;
-    private _hasCursor;
-    /**
-     * Whether the NUI frame is currently visible
-     */
-    get isVisible(): boolean;
-    /**
-     * Whether the NUI has input focus
-     */
-    get hasFocus(): boolean;
-    /**
-     * Whether the cursor is visible
-     */
-    get hasCursor(): boolean;
-    /**
-     * Send a message to the NUI (UI frame).
-     *
-     * @param action - The action/event name
-     * @param data - The data payload
-     */
-    send<K extends keyof TSend & string>(action: K, data: TSend[K]): void;
-    /**
-     * Send a raw message to the NUI without type checking.
-     *
-     * @param action - The action/event name
-     * @param data - The data payload
-     */
-    sendRaw(action: string, data: any): void;
-    /**
-     * Register a callback for NUI events from the UI.
-     *
-     * @param action - The action/event name to listen for
-     * @param handler - The callback handler
-     * @returns Cleanup function to unregister the callback
-     */
-    on<K extends keyof TReceive & string>(action: K, handler: (data: TReceive[K]) => void | Promise<void>): void;
-    /**
-     * Register a callback that expects a return value.
-     *
-     * @param action - The action/event name to listen for
-     * @param handler - The callback handler that returns data
-     */
-    onWithResponse<K extends keyof TReceive & string, R = any>(action: K, handler: (data: TReceive[K]) => R | Promise<R>): void;
-    /**
-     * Set NUI focus state.
-     *
-     * @param hasFocus - Whether the NUI should have input focus
-     * @param hasCursor - Whether to show the cursor (defaults to hasFocus value)
-     */
-    focus(hasFocus: boolean, hasCursor?: boolean): void;
-    /**
-     * Remove NUI focus (convenience method).
-     */
-    blur(): void;
-    /**
-     * Set NUI visibility state.
-     * Note: This only tracks state, you need to handle actual visibility in your UI.
-     *
-     * @param visible - Whether the NUI should be visible
-     */
-    setVisible(visible: boolean): void;
-    /**
-     * Show the NUI and optionally set focus.
-     *
-     * @param withFocus - Whether to also set focus
-     * @param withCursor - Whether to show cursor (defaults to withFocus)
-     */
-    show(withFocus?: boolean, withCursor?: boolean): void;
-    /**
-     * Hide the NUI and remove focus.
-     */
-    hide(): void;
-    /**
-     * Toggle NUI visibility.
-     *
-     * @param withFocus - Whether to set focus when showing
-     */
-    toggle(withFocus?: boolean): void;
-    /**
-     * Keep input focus but allow game input.
-     * Useful for HUDs that need to capture some keys but not all.
-     *
-     * @param keepInput - Whether to keep game input enabled
-     */
-    setKeepInput(keepInput: boolean): void;
-}
-/**
- * Default untyped NUI instance for quick usage.
- * For type-safe usage, create your own instance with proper generics.
- */
-export declare const NUI: NuiBridge<Record<string, any>, Record<string, any>>;
+export { NUI, NuiBridge, WebView, WebViewBridge } from './webview-bridge';