@omniviewdev/runtime 0.0.0-nightly.20260225

package/dist/router/Link.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { LinkProps as OriginalLinkProps } from 'react-router-dom';
+type LinkProps = {
+    /** The path to link to */
+    to: string;
+    /** Navigate within the current context */
+    withinContext?: boolean;
+} & Omit<OriginalLinkProps, 'to'>;
+/**
+ * Renders a history-aware link to a route. If `withinContext` is true, the link is resolved
+ * within the current context, appending the link to the current plugin and contextID path.
+ * Otherwise, it navigates to the specified `to` path.
+ *
+ * If `withinContext` is true and the current contextID is not available, the link will be
+ * resolved as if `withinContext` was false.
+ *
+ * @example
+ * import { Link } from '@omniviewdev/runtime/router';
+ *
+ * <Link to="/servers" withinContext>Go to Servers</Link>
+ * <Link to="/dashboard">Go to Dashboard</Link>
+ */
+declare const Link: React.FC<LinkProps>;
+export default Link;

package/dist/router/index.d.ts

@@ -0,0 +1,11 @@
+import { default as Link } from './Link';
+import { default as usePluginRouter } from './usePluginRouter';
+export { Link, usePluginRouter };
+declare const _default: {
+    Link: import('react').FC<{
+        to: string;
+        withinContext?: boolean;
+    } & Omit<import('react-router-dom').LinkProps, "to">>;
+    usePluginRouter: typeof usePluginRouter;
+};
+export default _default;

package/dist/router/usePluginRouter.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Options for customizing navigation behavior
+ */
+type PluginNavigateOptions = {
+    /** Replace the current entry in the history stack */
+    replace?: boolean;
+};
+/**
+ * Programatically route within a plugin.
+ *
+ * Navigation behavior:
+ * - Absolute paths (starting with `/`) are resolved relative to the plugin root.
+ *   e.g. `navigate('/cluster/abc')` → `/_plugin/{pluginId}/cluster/abc`
+ * - Relative paths (no leading `/`) use react-router's native relative resolution,
+ *   navigating relative to the current matched route.
+ *   e.g. `navigate('metrics')` → sibling route `metrics`
+ *   e.g. `navigate('.')` → current route (index)
+ *   e.g. `navigate('..')` → parent route
+ *
+ * @example
+ * ```
+ * import { usePluginRouter } from '@omniviewdev/runtime';
+ *
+ * export const MyComponent = () => {
+ *    const { navigate, pluginPath } = usePluginRouter();
+ *
+ *    // Absolute plugin-relative navigation
+ *    navigate('/cluster/abc/resources');
+ *
+ *    // Relative navigation (to sibling route)
+ *    navigate('metrics');
+ * }
+ * ```
+ */
+declare function usePluginRouter(): {
+    location: import('react-router-dom').Location<any>;
+    navigate: (path: string, opts?: PluginNavigateOptions) => void;
+    pluginPath: string;
+};
+export default usePluginRouter;

package/dist/runtime.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function w(n){window.runtime.LogPrint(n)}function d(n){window.runtime.LogTrace(n)}function r(n){window.runtime.LogDebug(n)}function u(n){window.runtime.LogInfo(n)}function m(n){window.runtime.LogWarning(n)}function l(n){window.runtime.LogError(n)}function s(n){window.runtime.LogFatal(n)}function o(n,i,e){return window.runtime.EventsOnMultiple(n,i,e)}function W(n,i){return o(n,i,-1)}function f(n,...i){return window.runtime.EventsOff(n,...i)}function c(){return window.runtime.EventsOffAll()}function a(n,i){return o(n,i,1)}function S(n){let i=[n].slice.call(arguments);return window.runtime.EventsEmit.apply(null,i)}function g(){window.runtime.WindowReload()}function p(){window.runtime.WindowReloadApp()}function O(n){window.runtime.WindowSetAlwaysOnTop(n)}function T(){window.runtime.WindowSetSystemDefaultTheme()}function L(){window.runtime.WindowSetLightTheme()}function v(){window.runtime.WindowSetDarkTheme()}function E(){window.runtime.WindowCenter()}function M(n){window.runtime.WindowSetTitle(n)}function h(){window.runtime.WindowFullscreen()}function x(){window.runtime.WindowUnfullscreen()}function F(){return window.runtime.WindowIsFullscreen()}function P(){return window.runtime.WindowGetSize()}function C(n,i){window.runtime.WindowSetSize(n,i)}function D(n,i){window.runtime.WindowSetMaxSize(n,i)}function I(n,i){window.runtime.WindowSetMinSize(n,i)}function R(n,i){window.runtime.WindowSetPosition(n,i)}function z(){return window.runtime.WindowGetPosition()}function A(){window.runtime.WindowHide()}function G(){window.runtime.WindowShow()}function U(){window.runtime.WindowMaximise()}function b(){window.runtime.WindowToggleMaximise()}function y(){window.runtime.WindowUnmaximise()}function k(){return window.runtime.WindowIsMaximised()}function B(){window.runtime.WindowMinimise()}function H(){window.runtime.WindowUnminimise()}function N(n,i,e,t){window.runtime.WindowSetBackgroundColour(n,i,e,t)}function Q(){return window.runtime.ScreenGetAll()}function j(){return window.runtime.WindowIsMinimised()}function q(){return window.runtime.WindowIsNormal()}function J(n){window.runtime.BrowserOpenURL(n)}function K(){return window.runtime.Environment()}function V(){window.runtime.Quit()}function X(){window.runtime.Hide()}function Y(){window.runtime.Show()}function Z(){return window.runtime.ClipboardGetText()}function _(n){return window.runtime.ClipboardSetText(n)}function $(n,i){return window.runtime.OnFileDrop(n,i)}function nn(){return window.runtime.OnFileDropOff()}function en(){return window.runtime.CanResolveFilePaths()}function on(n){return window.runtime.ResolveFilePaths(n)}exports.BrowserOpenURL=J;exports.CanResolveFilePaths=en;exports.ClipboardGetText=Z;exports.ClipboardSetText=_;exports.Environment=K;exports.EventsEmit=S;exports.EventsOff=f;exports.EventsOffAll=c;exports.EventsOn=W;exports.EventsOnMultiple=o;exports.EventsOnce=a;exports.Hide=X;exports.LogDebug=r;exports.LogError=l;exports.LogFatal=s;exports.LogInfo=u;exports.LogPrint=w;exports.LogTrace=d;exports.LogWarning=m;exports.OnFileDrop=$;exports.OnFileDropOff=nn;exports.Quit=V;exports.ResolveFilePaths=on;exports.ScreenGetAll=Q;exports.Show=Y;exports.WindowCenter=E;exports.WindowFullscreen=h;exports.WindowGetPosition=z;exports.WindowGetSize=P;exports.WindowHide=A;exports.WindowIsFullscreen=F;exports.WindowIsMaximised=k;exports.WindowIsMinimised=j;exports.WindowIsNormal=q;exports.WindowMaximise=U;exports.WindowMinimise=B;exports.WindowReload=g;exports.WindowReloadApp=p;exports.WindowSetAlwaysOnTop=O;exports.WindowSetBackgroundColour=N;exports.WindowSetDarkTheme=v;exports.WindowSetLightTheme=L;exports.WindowSetMaxSize=D;exports.WindowSetMinSize=I;exports.WindowSetPosition=R;exports.WindowSetSize=C;exports.WindowSetSystemDefaultTheme=T;exports.WindowSetTitle=M;exports.WindowShow=G;exports.WindowToggleMaximise=b;exports.WindowUnfullscreen=x;exports.WindowUnmaximise=y;exports.WindowUnminimise=H;

package/dist/runtime.d.ts

@@ -0,0 +1 @@
+export * from './wailsjs/runtime/runtime';

package/dist/runtime.js

@@ -0,0 +1,215 @@
+function w(n) {
+  window.runtime.LogPrint(n);
+}
+function u(n) {
+  window.runtime.LogTrace(n);
+}
+function r(n) {
+  window.runtime.LogDebug(n);
+}
+function d(n) {
+  window.runtime.LogInfo(n);
+}
+function m(n) {
+  window.runtime.LogWarning(n);
+}
+function f(n) {
+  window.runtime.LogError(n);
+}
+function c(n) {
+  window.runtime.LogFatal(n);
+}
+function e(n, i, o) {
+  return window.runtime.EventsOnMultiple(n, i, o);
+}
+function l(n, i) {
+  return e(n, i, -1);
+}
+function s(n, ...i) {
+  return window.runtime.EventsOff(n, ...i);
+}
+function W() {
+  return window.runtime.EventsOffAll();
+}
+function a(n, i) {
+  return e(n, i, 1);
+}
+function S(n) {
+  let i = [n].slice.call(arguments);
+  return window.runtime.EventsEmit.apply(null, i);
+}
+function g() {
+  window.runtime.WindowReload();
+}
+function p() {
+  window.runtime.WindowReloadApp();
+}
+function L(n) {
+  window.runtime.WindowSetAlwaysOnTop(n);
+}
+function O() {
+  window.runtime.WindowSetSystemDefaultTheme();
+}
+function T() {
+  window.runtime.WindowSetLightTheme();
+}
+function h() {
+  window.runtime.WindowSetDarkTheme();
+}
+function v() {
+  window.runtime.WindowCenter();
+}
+function E(n) {
+  window.runtime.WindowSetTitle(n);
+}
+function M() {
+  window.runtime.WindowFullscreen();
+}
+function x() {
+  window.runtime.WindowUnfullscreen();
+}
+function F() {
+  return window.runtime.WindowIsFullscreen();
+}
+function C() {
+  return window.runtime.WindowGetSize();
+}
+function D(n, i) {
+  window.runtime.WindowSetSize(n, i);
+}
+function I(n, i) {
+  window.runtime.WindowSetMaxSize(n, i);
+}
+function P(n, i) {
+  window.runtime.WindowSetMinSize(n, i);
+}
+function R(n, i) {
+  window.runtime.WindowSetPosition(n, i);
+}
+function z() {
+  return window.runtime.WindowGetPosition();
+}
+function A() {
+  window.runtime.WindowHide();
+}
+function G() {
+  window.runtime.WindowShow();
+}
+function U() {
+  window.runtime.WindowMaximise();
+}
+function b() {
+  window.runtime.WindowToggleMaximise();
+}
+function y() {
+  window.runtime.WindowUnmaximise();
+}
+function k() {
+  return window.runtime.WindowIsMaximised();
+}
+function B() {
+  window.runtime.WindowMinimise();
+}
+function H() {
+  window.runtime.WindowUnminimise();
+}
+function N(n, i, o, t) {
+  window.runtime.WindowSetBackgroundColour(n, i, o, t);
+}
+function Q() {
+  return window.runtime.ScreenGetAll();
+}
+function j() {
+  return window.runtime.WindowIsMinimised();
+}
+function q() {
+  return window.runtime.WindowIsNormal();
+}
+function J(n) {
+  window.runtime.BrowserOpenURL(n);
+}
+function K() {
+  return window.runtime.Environment();
+}
+function V() {
+  window.runtime.Quit();
+}
+function X() {
+  window.runtime.Hide();
+}
+function Y() {
+  window.runtime.Show();
+}
+function Z() {
+  return window.runtime.ClipboardGetText();
+}
+function _(n) {
+  return window.runtime.ClipboardSetText(n);
+}
+function $(n, i) {
+  return window.runtime.OnFileDrop(n, i);
+}
+function nn() {
+  return window.runtime.OnFileDropOff();
+}
+function on() {
+  return window.runtime.CanResolveFilePaths();
+}
+function en(n) {
+  return window.runtime.ResolveFilePaths(n);
+}
+export {
+  J as BrowserOpenURL,
+  on as CanResolveFilePaths,
+  Z as ClipboardGetText,
+  _ as ClipboardSetText,
+  K as Environment,
+  S as EventsEmit,
+  s as EventsOff,
+  W as EventsOffAll,
+  l as EventsOn,
+  e as EventsOnMultiple,
+  a as EventsOnce,
+  X as Hide,
+  r as LogDebug,
+  f as LogError,
+  c as LogFatal,
+  d as LogInfo,
+  w as LogPrint,
+  u as LogTrace,
+  m as LogWarning,
+  $ as OnFileDrop,
+  nn as OnFileDropOff,
+  V as Quit,
+  en as ResolveFilePaths,
+  Q as ScreenGetAll,
+  Y as Show,
+  v as WindowCenter,
+  M as WindowFullscreen,
+  z as WindowGetPosition,
+  C as WindowGetSize,
+  A as WindowHide,
+  F as WindowIsFullscreen,
+  k as WindowIsMaximised,
+  j as WindowIsMinimised,
+  q as WindowIsNormal,
+  U as WindowMaximise,
+  B as WindowMinimise,
+  g as WindowReload,
+  p as WindowReloadApp,
+  L as WindowSetAlwaysOnTop,
+  N as WindowSetBackgroundColour,
+  h as WindowSetDarkTheme,
+  T as WindowSetLightTheme,
+  I as WindowSetMaxSize,
+  P as WindowSetMinSize,
+  R as WindowSetPosition,
+  D as WindowSetSize,
+  O as WindowSetSystemDefaultTheme,
+  E as WindowSetTitle,
+  G as WindowShow,
+  b as WindowToggleMaximise,
+  x as WindowUnfullscreen,
+  y as WindowUnmaximise,
+  H as WindowUnminimise
+};

package/dist/types/app.d.ts

@@ -0,0 +1,73 @@
+import { default as React, ComponentType } from 'react';
+import { ExtensionPointSettings } from './extensions';
+import { RouteObject } from 'react-router-dom';
+/** TODO: Add whatever props we need here */
+export declare class PluginWindowRootProps {
+}
+/**
+ * Plugin container is the main type that is rendered for a visual component within the
+ * user interface.
+ */
+export declare class PluginWindow {
+    _extensions?: Array<ExtensionPointSettings>;
+    /**
+     * The root component to render for the application window.
+     */
+    root?: ComponentType;
+    /**
+     * Various pages to render under the root component. These can be navigated to using
+     * the built-in navigation system both programatically and through Links.
+     *
+     * @example
+     * Programatically:
+     * ```
+     * import { usePluginNavigation } from '@omniviewdev/runtime';
+     * const MyComponent = () => {
+     *  const { navigate } = usePluginNavigation();
+     *
+     *  const goToPage = () => {
+     *      navigate('some-page')
+     *  }
+     *
+     * }
+     * ```
+     *
+     * Using Links:
+     * ```
+     * import { Link } from '@omniviewdev/runtime';
+     * const MyComponent = () => {
+     *  return (
+     *    <Link to="some-page">
+     *  )
+     * }
+     * ```
+     *
+     */
+    pages?: Record<string, ComponentType>;
+    _routes?: Array<RouteObject>;
+    get extensions(): ExtensionPointSettings[];
+    get Routes(): Array<RouteObject>;
+    /**
+     * Get's the route provider component to render within the plugin view
+     */
+    get Window(): React.ReactNode;
+    /**
+     * Register extension points for other plugins to extend the functionality
+     * of the plugin. All extension points registered will be name as such:
+     *
+     * `${plugin_id}/${extension_point_id}`
+     */
+    registerExtensionPoints(points: Array<ExtensionPointSettings>): this;
+    /**
+     * Set the component displayed under:
+     *   /_plugin/${plugin_id}/*
+     *
+     * If the NavModel is configured, the page will have a managed frame, otheriwse it has full control.
+     */
+    setRootPage(root: ComponentType<PluginWindowRootProps>): this;
+    /**
+     * Adds a page to the plugin window. This page will be displayed under:
+     */
+    withPage(page: string, component: ComponentType): this;
+    withRoutes(routes: Array<RouteObject>): this;
+}

package/dist/types/extensions.d.ts

@@ -0,0 +1,186 @@
+export type ExtensionPointSettings = {
+    /**
+    * The ID of the plugin (or 'core') that owns the extension point
+    */
+    owner: string;
+    /**
+    * The ID of the extension point
+    */
+    id: string;
+    /**
+    * The human readable label for the extension point
+    */
+    name: string;
+    /**
+    * A description of the extension point
+    */
+    description?: string;
+    /**
+    * Set the extension point to support rendering multiple components or a single component.
+    */
+    mode: 'single' | 'multiple';
+    /**
+    * Disable the extension point to prevent rendering components.
+    * This is useful when the extension point should be disabled temporarily.
+    */
+    disabled?: boolean;
+    /**
+    * Selected component to render when the extension point is in single-component mode.
+    */
+    selected?: string;
+    /**
+    * The order in which the components should be rendered when the extension point is in multiple-component mode.
+    */
+    order?: string[];
+};
+/**
+ * Options required during registration of the extension to the extension point's registry.
+ */
+export type RegisterOpts<Props> = {
+    /**
+     * The ID of the registered component
+     */
+    id: string;
+    /**
+     * The plugin that owns the view
+     */
+    plugin: string;
+    /**
+     * The human readable label for the component
+     */
+    label: string;
+    /**
+     * A description of the component
+     */
+    description?: string;
+    /**
+     * The component to render
+     */
+    component: React.Component<Props>;
+    /**
+     * Additional optional metadata for the component
+     */
+    meta?: unknown;
+};
+export type Registration<Props> = RegisterOpts<Props> & {
+    /**
+    * The time the component was registered
+    */
+    registeredAt: Date;
+    /**
+    * The time the component was last updated
+    * This will be the same as `registeredAt` if the component has not been updated
+    */
+    updatedAt: Date;
+    /**
+    * Whether the component is enabled
+    * This can be used to disable a component without unregistering it.
+    */
+    enabled?: boolean;
+};
+/**
+ * Context that can be passed to the registry to provide additional information to the matcher.
+ * The context should generate a cache key that can be used to cache the results of the matcher
+ * to avoid recalculating the same result multiple times.
+ */
+export type ExtensionRenderContext = {
+    getCacheKey: () => string;
+};
+export type CreateExtensionPointOptions<ComponentProps> = ExtensionPointSettings & {
+    /**
+     * Define a custom matcher to use to find which extensions to register based on any number of args.
+     * This is useful when the extension should only be registered for certain resources, like for example
+     * when a registry contains components that should only be rendered for specific resources.
+     *
+     * @param context The context to use to determine if the extension should be registered. The extension point
+     *                renderer will call this function with the context provided by the extension point.
+     * @param item The item to check if it should be registered
+     * @returns Whether the item should be registered
+     */
+    matcher?: (context: ExtensionRenderContext, item: Registration<ComponentProps>) => boolean;
+};
+/**
+ * A registry to hold an extension points registered extensions, providing type safe access to the components.
+ *
+ * @param ComponentProps The props type for the component that is registered in the registry.
+ */
+export declare class ExtensionPointStore<ComponentProps> {
+    private readonly _settings;
+    private readonly _extensions;
+    private readonly _lookupCache;
+    private readonly _matchCache;
+    private readonly _matcher?;
+    constructor(opts: CreateExtensionPointOptions<ComponentProps>);
+    settings(): ExtensionPointSettings;
+    /**
+    * Registers a new component within the registry. Throws an error if a component with the same ID already exists.
+    * This method should be used when initializing components or dynamically adding new components at runtime.
+    *
+    * @param opts The registration options for the component, containing its ID, plugin, and other metadata.
+    * @throws Error if a component with the same ID is already registered.
+    * @example
+    * registry.register({
+    *   id: 'unique-sidebar-item',
+    *   plugin: 'examplePlugin',
+    *   label: 'My Sidebar Item',
+    *   component: MyComponent,
+    * });
+    */
+    register(opts: RegisterOpts<ComponentProps>): void;
+    /**
+    * Unregisters a component from the registry by its ID. Useful for cleanup or when components are dynamically removed.
+    *
+    * @param id The ID of the component to unregister.
+    * @example
+    * registry.unregister('unique-sidebar-item');
+    */
+    unregister(id: string): void;
+    /**
+    * Retrieves a component by its ID from the registry. Returns undefined if no such component exists.
+    *
+    * @param id The ID of the component to retrieve.
+    * @returns The component associated with the given ID, or undefined if not found.
+    * @example
+    * const component = registry.get('unique-sidebar-item');
+    * if (component) {
+    *   render(component);
+    * }
+    */
+    get(id: string): import('react').Component<ComponentProps, {}, any> | undefined;
+    /**
+    * Lists all registered components in the registry. Useful for debugging or generating summaries of available components.
+    *
+    * @returns An array of all registered components.
+    * @example
+    * const allComponents = registry.list();
+    * console.log('Registered Components:', allComponents);
+    */
+    list(): Registration<ComponentProps>[];
+    generateMatchCacheKey(item: Registration<ComponentProps>): string;
+    /**
+     * Calculate the matches for the given context.
+     */
+    calculateMatches(context: ExtensionRenderContext): Registration<ComponentProps>[];
+    /**
+     * Preload the registry caches with the given expected context to avoid on-first-request calculation.
+     * This is useful when the registry is used to provide components for a specific context, like for
+     * specific resources types.
+     *
+     * If the cache is already populated for the expected context, the cache key will be recalculated.
+     *
+     * @param context The context expected to be called preload the registry with on provide.
+     */
+    preload(context: ExtensionRenderContext): void;
+    /**
+     * Provide the components that match the given context.
+     */
+    provide(context: ExtensionRenderContext): Array<React.Component<ComponentProps>>;
+    reorderComponents(components: Array<React.Component<ComponentProps>>, ids: string[], order: string[]): Array<React.Component<ComponentProps>>;
+    /**
+     * Reorder the components in the registry based on the given order.
+     */
+    reorder(order: string[]): void;
+    clearLookupCache(): void;
+    clearMatchCache(): void;
+    clearAllCaches(): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './app';
+export * from './plugin';
+export * from './extensions';
+export * from './informer';

package/dist/types/informer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * InformerSyncPolicy controls when an informer starts for a resource type.
+ */
+export declare enum InformerSyncPolicy {
+    /** Start when connection opens (default) */
+    OnConnect = 0,
+    /** Start on first Get/List/Find for this resource */
+    OnFirstQuery = 1,
+    /** Never start an informer (always use direct queries) */
+    Never = 2
+}
+/**
+ * InformerResourceState represents the sync state of a single resource type's informer.
+ */
+export declare enum InformerResourceState {
+    Pending = 0,
+    Syncing = 1,
+    Synced = 2,
+    Error = 3,
+    Cancelled = 4
+}
+/**
+ * InformerStateEvent is emitted when a resource's informer state changes.
+ */
+export interface InformerStateEvent {
+    pluginId: string;
+    connection: string;
+    resourceKey: string;
+    state: InformerResourceState;
+    resourceCount: number;
+    totalCount: number;
+    error?: {
+        code: string;
+        title: string;
+        message: string;
+        suggestions?: string[];
+    };
+}
+/**
+ * InformerConnectionSummary provides an aggregate view of all informer states for a connection.
+ */
+export interface InformerConnectionSummary {
+    connection: string;
+    resources: Record<string, InformerResourceState>;
+    resourceCounts: Record<string, number>;
+    totalResources: number;
+    syncedCount: number;
+    errorCount: number;
+}

package/dist/types/plugin.d.ts

@@ -0,0 +1,5 @@
+export declare enum PluginErrorCode {
+    MISSING_MANIFEST = "MISSING_MANIFEST",
+    MISSING_PLUGIN = "MISSING_PLUGIN",
+    MISSING_ENTRYPOINT = "MISSING_ENTRYPOINT"
+}

package/dist/utils/activeSyncAggregator.d.ts

@@ -0,0 +1,29 @@
+import { InformerResourceState, InformerStateEvent } from '../types/informer';
+export interface ActiveSync {
+    pluginID: string;
+    connectionID: string;
+    totalResources: number;
+    syncedCount: number;
+    errorCount: number;
+    /** Count of resources in any terminal state (Synced + Error + Cancelled) */
+    doneCount: number;
+    /** 0-1 progress fraction */
+    progress: number;
+}
+export interface ResourceTracker {
+    states: Record<string, InformerResourceState>;
+    pluginID: string;
+    connectionID: string;
+}
+/** Compute an ActiveSync from a ResourceTracker */
+export declare function computeActiveSync(tracker: ResourceTracker): ActiveSync;
+/** Whether a sync is considered "done" (all resources reached terminal state) */
+export declare function isSyncDone(sync: ActiveSync): boolean;
+/** Whether any syncs are still actively in progress */
+export declare function hasActiveSyncing(syncs: ActiveSync[]): boolean;
+/** Compute aggregate progress across multiple syncs */
+export declare function aggregateProgress(syncs: ActiveSync[]): number;
+/** Build a tracker key from an event */
+export declare function trackerKey(event: InformerStateEvent): string;
+/** Update a trackers map with a new event, returning the updated tracker */
+export declare function updateTracker(trackers: Map<string, ResourceTracker>, event: InformerStateEvent): ResourceTracker;

package/dist/utils/activeSyncAggregator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/wailsjs/go/data/Client.d.ts

@@ -0,0 +1,10 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+export function Delete(arg1:string,arg2:string):Promise<void>;
+
+export function Get(arg1:string,arg2:string):Promise<any>;
+
+export function Keys(arg1:string):Promise<Array<string>>;
+
+export function Set(arg1:string,arg2:string,arg3:any):Promise<void>;