@omniviewdev/runtime 0.1.0

package/dist/api.js

@@ -0,0 +1,120 @@
+import { C as j, f as x, g as z, a as E, p as R, b as h, c as A, d as W, e as U } from "./Client-DGdSmmVk.js";
+function t(e) {
+  return window.go.utils.Client.DetectLanguage(e);
+}
+const L = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DetectLanguage: t
+}, Symbol.toStringTag, { value: "Module" }));
+function i(e, n) {
+  return window.go.diagnostics.DiagnosticsClient.Debug(e, n);
+}
+function o(e, n) {
+  return window.go.diagnostics.DiagnosticsClient.Error(e, n);
+}
+function a(e, n) {
+  return window.go.diagnostics.DiagnosticsClient.Info(e, n);
+}
+function g(e, n, r) {
+  return window.go.diagnostics.DiagnosticsClient.Log(e, n, r);
+}
+function v(e) {
+  return window.go.diagnostics.DiagnosticsClient.ReadLog(e);
+}
+function s(e) {
+  return window.go.diagnostics.DiagnosticsClient.StartTail(e);
+}
+function u(e) {
+  return window.go.diagnostics.DiagnosticsClient.StopTail(e);
+}
+function l(e, n) {
+  return window.go.diagnostics.DiagnosticsClient.Warn(e, n);
+}
+const m = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Debug: i,
+  Error: o,
+  Info: a,
+  Log: g,
+  ReadLog: v,
+  StartTail: s,
+  StopTail: u,
+  Warn: l
+}, Symbol.toStringTag, { value: "Module" }));
+function c(e, n) {
+  return window.go.devserver.DevServerManager.GetDevServerLogs(e, n);
+}
+function d(e) {
+  return window.go.devserver.DevServerManager.GetDevServerState(e);
+}
+function S(e) {
+  return window.go.devserver.DevServerManager.GetExternalPluginInfo(e);
+}
+function w(e) {
+  return window.go.devserver.DevServerManager.Initialize(e);
+}
+function D(e) {
+  return window.go.devserver.DevServerManager.IsManaged(e);
+}
+function f() {
+  return window.go.devserver.DevServerManager.ListDevServerStates();
+}
+function p(e) {
+  return window.go.devserver.DevServerManager.RestartDevServer(e);
+}
+function C() {
+  return window.go.devserver.DevServerManager.Shutdown();
+}
+function M(e) {
+  return window.go.devserver.DevServerManager.StartDevServer(e);
+}
+function b(e, n) {
+  return window.go.devserver.DevServerManager.StartDevServerForPath(e, n);
+}
+function _(e) {
+  return window.go.devserver.DevServerManager.StopDevServer(e);
+}
+const O = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  GetDevServerLogs: c,
+  GetDevServerState: d,
+  GetExternalPluginInfo: S,
+  Initialize: w,
+  IsManaged: D,
+  ListDevServerStates: f,
+  RestartDevServer: p,
+  Shutdown: C,
+  StartDevServer: M,
+  StartDevServerForPath: b,
+  StopDevServer: _
+}, Symbol.toStringTag, { value: "Module" }));
+function I() {
+  return window.go.main.App.GetOperatingSystem();
+}
+function P(e) {
+  return window.go.main.App.OpenFileSelectionDialog(e);
+}
+function y(e) {
+  return window.go.main.App.SaveFileDialog(e);
+}
+function F(e, n) {
+  return window.go.main.App.WriteFileContent(e, n);
+}
+export {
+  O as DevServerManager,
+  m as DiagnosticsClient,
+  j as ExecClient,
+  I as GetOperatingSystem,
+  x as LogsClient,
+  z as MetricClient,
+  E as NetworkerClient,
+  P as OpenFileSelectionDialog,
+  R as PluginManager,
+  h as ResourceClient,
+  y as SaveFileDialog,
+  A as SettingsClient,
+  W as SettingsProvider,
+  U as UIClient,
+  L as UtilsClient,
+  F as WriteFileContent
+};

package/dist/context/drawer/BottomDrawerContext.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { CreateTab, FocusTab, CloseDrawer, FullscreenDrawer, CloseTab, ResizeDrawer, BottomDrawerTab, CreateTabs, CloseTabs, ReorderTab, UpdateTab } from './types';
+export type BottomDrawerContextType = {
+    height: number;
+    focused: number;
+    tabs: BottomDrawerTab[];
+    createTab: CreateTab;
+    createTabs: CreateTabs;
+    updateTab: UpdateTab;
+    focusTab: FocusTab;
+    closeTab: CloseTab;
+    closeTabs: CloseTabs;
+    reorderTab: ReorderTab;
+    resizeDrawer: ResizeDrawer;
+    closeDrawer: CloseDrawer;
+    fullscreenDrawer: FullscreenDrawer;
+};
+export declare const defaultState: BottomDrawerContextType;
+export declare const BottomDrawerContext: React.Context<BottomDrawerContextType>;
+export default BottomDrawerContext;

package/dist/context/drawer/RightDrawerContext.d.ts

@@ -0,0 +1,15 @@
+import { DrawerComponent, DrawerContext } from './types';
+export type ShowResourceSidebarParams = {
+    pluginID: string;
+    connectionID: string;
+    resourceKey: string;
+    resourceID: string;
+    namespace?: string;
+};
+export interface RightDrawerContextType {
+    openDrawer: (component: DrawerComponent, ctx: DrawerContext) => void;
+    closeDrawer: () => void;
+    showResourceSidebar: (params: ShowResourceSidebarParams) => void;
+    isOpen: boolean;
+}
+export declare const RightDrawerContext: import('react').Context<RightDrawerContextType | undefined>;

package/dist/context/drawer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './BottomDrawerContext';
+export * from './RightDrawerContext';

package/dist/context/drawer/types.d.ts

@@ -0,0 +1,222 @@
+import { ReactNode } from 'react';
+/**
+ * A factory function that produces a DrawerComponent for a given resource.
+ * Plugins export these keyed by resource key so the host can build the full
+ * sidebar (views + actions) for linked-resource navigation, ref-chip clicks, etc.
+ *
+ * The factory receives a close callback so actions can dismiss the drawer.
+ */
+export type DrawerFactory<T = any> = (closeDrawer: () => void) => DrawerComponent<T>;
+export type DrawerComponent<T = any> = {
+    /**
+     * The title to display in the drawer header
+     */
+    title: string | ReactNode;
+    /**
+     * The icon to display in the drawer header to the left of the the title
+     */
+    icon?: ReactNode;
+    /**
+     * The various views to display within the drawer. This should be used to
+     * allow other plugins to extend the current functionality.
+     *
+     * There must be at least one view within the drawer.
+     */
+    views: Array<DrawerComponentView<T>>;
+    /**
+     * Functions that can be triggered upon clicking the component. These items
+     * do not change what is in the viewport of the drawer, but instead trigger
+     * other actions (such as starting a terminal session, modifying a resource,
+     * etc.)
+     *
+     * There must be at least one action within the drawer.
+     */
+    actions: Array<DrawerComponentAction<T>>;
+};
+export type DrawerComponentView<T = any> = {
+    /**
+     * The title to display for the drawer header tooltip
+     */
+    title: string | ReactNode;
+    /**
+     * The icon to display in the drawer's pages section
+     */
+    icon?: ReactNode;
+    /**
+     * The component to display in the viewport upon click.
+     *
+     * When a plugin is extending with a page, the component may choose to
+     * pass data about what is inside the component. This is typically the case
+     * with drawers that display resource information.
+     */
+    component: (ctx: DrawerContext<T>) => ReactNode;
+};
+/**
+ * An action that can be run on a resource.
+ */
+export type DrawerComponentAction<T = any> = {
+    /**
+     * The title to display for the drawer header tooltip
+     */
+    title: string | ReactNode;
+    /**
+     * The icon to display in the drawer header to the left of the the title
+     */
+    icon?: ReactNode;
+    /**
+     * Determines whether the action should be shown. This is useful when the action
+     * is only applicable if the resource has certain parameters, should only be
+     * done for certain connections, or should be available only for certain resource
+     * types.
+     */
+    enabled?: ((ctx: DrawerContext<T>) => boolean) | boolean;
+    /**
+     * The function to run for the drawer component on click.
+     *
+     * When a plugin is extending with an action, the component may choose to
+     * pass data about what is inside the component. This is typically the case
+     * with drawers that display resource information.
+     */
+    action?: (ctx: DrawerContext<T>) => void;
+    /**
+     * Have the action provide a list of actions underneath when clicked rather than
+     * initiation the action directly on click.
+     */
+    list?: ((ctx: DrawerContext<T>) => Array<DrawerComponentActionListItem>) | Array<DrawerComponentActionListItem>;
+};
+/**
+ * Displays a list item under the action
+ */
+export type DrawerComponentActionListItem<T = any> = {
+    /**
+     * The title to display for the drawer header tooltip
+     */
+    title: string | ReactNode;
+    /**
+     * The icon to display in list item to the left of the the name
+     */
+    icon?: ReactNode;
+    /**
+     * The function to run for the action list item on click.
+     *
+     * When a plugin is extending with an action, the component may choose to
+     * pass data about what is inside the component. This is typically the case
+     * with drawers that display resource information.
+     */
+    action: (ctx: DrawerContext<T>) => void;
+};
+/**
+ * Context that can be passed to the drawer instantiation
+ */
+export type DrawerContext<T = any> = {
+    /**
+     * Generic data supplied to the drawer. For resource displays, this should be
+     * the generic object data for the resource in question.
+     */
+    data?: T;
+    /**
+     * Resource information (if this drawer is being displayed as part of a resource)
+     */
+    resource?: {
+        /**
+         * The id of the resource in question
+         */
+        id: string;
+        /**
+         * The resource key that defines the globally-recognizable key
+         */
+        key: string;
+        /**
+        * A connection id, if this drawer is displaying something in the context
+        * of a connection.
+        */
+        connectionID: string;
+        /**
+         * The plugin that owns this resource. When provided, host-level features
+         * like the Events tab can be injected automatically.
+         */
+        pluginID?: string;
+    };
+};
+export type BottomDrawerTab = {
+    id: string;
+    title: string;
+    createdAt: Date;
+    updatedAt: Date;
+    icon?: string | React.ReactNode;
+    variant: 'terminal' | 'logs' | 'editor' | 'browser' | 'file' | 'devbuild' | 'other';
+    properties?: Record<string, unknown>;
+};
+export type FindTabOpts = {
+    /** ID of the tab to focus, if known */
+    id?: string;
+    /** Index of the tab, if known. If provided, it will be prioritized over all other options */
+    index?: number;
+    /** Properties to match against */
+    properties?: Record<string, unknown>;
+    /**
+     * Customize the behavior when multiple tabs match the properties. The options are:
+     *  - 'first': Perform on the first matching tab.
+     *  - 'newest': Perform the most recently created tab.
+     *  - 'oldest': Perform the oldest tab
+     *  - 'none': Do nothing
+     */
+    actionOnMultiple?: 'first' | 'newest' | 'oldest' | 'none';
+};
+export type CreateTabOpts = Pick<BottomDrawerTab, 'title' | 'icon' | 'variant' | 'properties'> & {
+    id?: string;
+};
+/**
+ * Create a new tab in the bottom drawer.
+ */
+export type CreateTab = (opts: CreateTabOpts) => void;
+/**
+ * Create multiple tabs in the bottom drawer.
+ */
+export type CreateTabs = (opts: CreateTabOpts[]) => void;
+/**
+* Focus on a tab in the bottom drawer. If multiple tabs match the search criteria, the 'newest' tab will be focused.
+*/
+export type FocusTab = (opts: FindTabOpts) => void;
+/**
+ * Reorder a tab in the bottom drawer, given the 'from' and 'to' indexes.
+ */
+export type ReorderTab = (from: number, to: number) => void;
+/**
+ * Close a tab in the bottom drawer. If multiple tabs match the search criteria, no tabs will be closed.
+ */
+export type CloseTab = (opts: FindTabOpts) => void;
+/**
+* Close multiple tabs in the bottom drawer.
+*/
+export type CloseTabs = (opts: FindTabOpts[]) => void;
+/**
+ * Resize the height of the bottom drawer programatically, in pixels.
+ */
+export type ResizeDrawer = (height: number) => void;
+/**
+ * Expand the bottom drawer to take up the full height of view.
+ */
+export type FullscreenDrawer = () => void;
+/**
+ * Collapse the bottom drawer to its default height.
+ */
+export type CloseDrawer = () => void;
+/**
+ * Options for updating an existing tab in the bottom drawer.
+ * The tab is located using FindTabOpts, then the remaining fields are applied.
+ */
+export type UpdateTabOpts = {
+    /** New ID to replace the existing tab ID */
+    id?: string;
+    /** New title */
+    title?: string;
+    /** New icon */
+    icon?: string | React.ReactNode;
+    /** Properties to merge into the tab's existing properties */
+    properties?: Record<string, unknown>;
+};
+/**
+ * Update an existing tab in the bottom drawer, located by FindTabOpts.
+ */
+export type UpdateTab = (find: FindTabOpts, updates: UpdateTabOpts) => void;

package/dist/context/index.d.ts

@@ -0,0 +1,5 @@
+export * from './plugins';
+export * from './settings';
+export * from './drawer';
+export * from './modal';
+export * from './operations/OperationsContext';

package/dist/context/modal/ConfirmationModalContext.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+export type ConfirmationModalProps = {
+    title?: string | React.ReactNode;
+    body?: string | React.ReactNode;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    onConfirm: () => Promise<void> | void;
+};
+export type ConfirmationModalContextType = {
+    show: (props: ConfirmationModalProps) => void;
+};
+export declare const ConfirmationModalContext: React.Context<ConfirmationModalContextType | undefined>;

package/dist/context/modal/index.d.ts

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

package/dist/context/operations/OperationsContext.d.ts

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+export type Operation = {
+    id: string;
+    label: string;
+    resourceKey: string;
+    resourceName: string;
+    namespace: string;
+    connectionID: string;
+    status: 'running' | 'completed' | 'error';
+    progress?: {
+        ready: number;
+        desired: number;
+    };
+    message?: string;
+    startedAt: number;
+    completedAt?: number;
+};
+export type OperationsContextType = {
+    operations: Operation[];
+    addOperation: (op: Operation) => void;
+    updateOperation: (id: string, updates: Partial<Operation>) => void;
+    removeOperation: (id: string) => void;
+};
+export declare const OperationsContext: React.Context<OperationsContextType | undefined>;
+export declare const OperationsProvider: React.FC<{
+    children: React.ReactNode;
+}>;

package/dist/context/plugins/PluginContext.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { config } from '../../wailsjs/go/models';
+export interface PluginContextType {
+    /** The runtime instance ID for this plugin (e.g. "kubernetes-dev" or "kubernetes"). */
+    pluginId: string;
+    meta: config.PluginMeta;
+    settings: Record<string, any>;
+}
+export declare const PluginContext: React.Context<PluginContextType | undefined>;

package/dist/context/plugins/PluginContextProvider.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export type PluginContextProviderProps = {
+    pluginId: string;
+};
+export declare function PluginContextProvider(props: React.PropsWithChildren<PluginContextProviderProps>): React.ReactElement;

package/dist/context/plugins/index.d.ts

@@ -0,0 +1,3 @@
+export * from './PluginContext';
+export * from './PluginContextProvider';
+export * from './usePluginContext';

package/dist/context/plugins/usePluginContext.d.ts

@@ -0,0 +1,3 @@
+import { PluginContextType } from './PluginContext';
+export declare function usePluginContext(): PluginContextType;
+export declare function usePluginSettings(): Record<string, any>;

package/dist/context/settings/SettingsContext.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export interface SettingsContextType {
+    settings: Record<string, any>;
+    reload: () => void;
+}
+export declare const SettingsContext: React.Context<SettingsContextType | undefined>;
+export declare const SettingsProvider: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/context/settings/index.d.ts

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

package/dist/errors/index.d.ts

@@ -0,0 +1,3 @@
+export { parseAppError, isCancelledError, actionToSnackbar, createErrorHandler, showAppError } from './parseAppError';
+export { ErrorTypes } from './types';
+export type { AppError, AppErrorAction } from './types';

package/dist/errors/parseAppError.d.ts

@@ -0,0 +1,51 @@
+import { AppError, AppErrorAction } from './types';
+/**
+ * Parse any error shape from the Wails boundary into a structured AppError.
+ *
+ * Handles:
+ * - JSON string from AppError.Error() → parsed into typed AppError
+ * - Plain string from old fmt.Errorf → wrapped as internal error
+ * - Error object → extracts .message, tries JSON parse
+ * - null/undefined → generic "Unknown error"
+ *
+ * NEVER returns null.
+ */
+export declare function parseAppError(error: unknown): AppError;
+/**
+ * Detects both new format (type === "omniview:cancelled") and legacy ("cancelled" string).
+ */
+export declare function isCancelledError(error: unknown): boolean;
+/**
+ * Converts an AppErrorAction into a { label, onClick } suitable for snackbar actions.
+ */
+export declare function actionToSnackbar(action: AppErrorAction): {
+    label: string;
+    onClick: () => void;
+};
+type ShowSnackbarFn = (options: {
+    message: string;
+    status: 'error' | 'warning' | 'info' | 'success' | 'default';
+    details?: string;
+    actions?: Array<{
+        label: string;
+        onClick: () => void;
+    }>;
+}) => void;
+/**
+ * Show a structured error snackbar from any Wails error.
+ * Parses the error, suppresses cancellations, and displays
+ * the full title/detail/suggestions/actions in the snackbar.
+ *
+ * @param showSnackbar - The snackbar function
+ * @param error - The raw error from Wails
+ * @param contextMessage - Optional context (e.g. "Failed to delete pod-1")
+ */
+export declare function showAppError(showSnackbar: ShowSnackbarFn, error: unknown, contextMessage?: string): void;
+/**
+ * Creates a drop-in onError handler that:
+ * - Suppresses cancelled errors
+ * - Parses structured AppError fields
+ * - Shows a snackbar with title, detail, suggestions, and actions
+ */
+export declare function createErrorHandler(showSnackbar: ShowSnackbarFn, fallbackTitle: string): (error: unknown) => void;
+export {};

package/dist/errors/parseAppError.test.d.ts

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

package/dist/errors/types.d.ts

@@ -0,0 +1,40 @@
+/** A frontend-renderable action attached to a structured error. */
+export interface AppErrorAction {
+    type: 'navigate' | 'retry' | 'open-url' | 'copy';
+    label: string;
+    target?: string;
+}
+/** Structured error matching the Go apperror.AppError JSON shape. */
+export interface AppError {
+    type: string;
+    title: string;
+    status: number;
+    detail: string;
+    instance?: string;
+    suggestions?: string[];
+    actions?: AppErrorAction[];
+}
+/** Error type URI constants matching Go apperror/types.go. */
+export declare const ErrorTypes: {
+    readonly PLUGIN_NOT_FOUND: "omniview:plugin/not-found";
+    readonly PLUGIN_NOT_LOADED: "omniview:plugin/not-loaded";
+    readonly PLUGIN_ALREADY_LOADED: "omniview:plugin/already-loaded";
+    readonly PLUGIN_INSTALL_FAILED: "omniview:plugin/install-failed";
+    readonly PLUGIN_LOAD_FAILED: "omniview:plugin/load-failed";
+    readonly PLUGIN_BUILD_FAILED: "omniview:plugin/build-failed";
+    readonly SETTINGS_MISSING_CONFIG: "omniview:settings/missing-config";
+    readonly SETTINGS_INVALID_CONFIG: "omniview:settings/invalid-config";
+    readonly RESOURCE_NOT_FOUND: "omniview:resource/not-found";
+    readonly RESOURCE_FORBIDDEN: "omniview:resource/forbidden";
+    readonly RESOURCE_UNAUTHORIZED: "omniview:resource/unauthorized";
+    readonly RESOURCE_CONFLICT: "omniview:resource/conflict";
+    readonly RESOURCE_TIMEOUT: "omniview:resource/timeout";
+    readonly CONNECTION_NOT_FOUND: "omniview:connection/not-found";
+    readonly CONNECTION_FAILED: "omniview:connection/failed";
+    readonly SESSION_NOT_FOUND: "omniview:session/not-found";
+    readonly SESSION_FAILED: "omniview:session/failed";
+    readonly CANCELLED: "omniview:cancelled";
+    readonly INTERNAL: "omniview:internal";
+    readonly VALIDATION: "omniview:validation";
+    readonly NOT_IMPLEMENTED: "omniview:not-implemented";
+};

package/dist/extensions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './provider';
+export * from './registry';

package/dist/extensions/points/resource/helpers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A resource parts object for matching a resource key.
+ */
+type ResourceParts = {
+    /** The group the resource belongs to */
+    group: string | string[];
+    /** The version of the resource */
+    version: string | string[];
+    /** The kind of the resource */
+    kind: string | string[];
+};
+/**
+* Check if a resource matches the given parts.
+* @param extensionId The extension ID to cache the result for
+* @param resource The resource to check
+* @param parts The parts to match
+*/
+export declare const matchesResource: (cache: Map<string, boolean>, extensionId: string, resource: string, matcher: string | string[] | RegExp | ResourceParts) => boolean;
+export {};

package/dist/extensions/points/resource/types.d.ts

@@ -0,0 +1,6 @@
+export type ResourceViewRegistry<T> = {
+    register(opts: T): void;
+    unregister(id: string): void;
+    get(id: string): T | undefined;
+    getViews(plugin: string, resource: string): T[];
+};

package/dist/extensions/provider.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { ExtensionPointRegistry } from './registry';
+import { ExtensionPointStore } from '../types';
+type ExtensionProviderProps = {
+    /** Allow passing in a custom registry, purely for testing purposes */
+    registry: ExtensionPointRegistry;
+    children: React.ReactNode;
+};
+export type ExtensionProviderType = React.FC<ExtensionProviderProps>;
+export declare const useExtensionRegistry: () => ExtensionPointRegistry | undefined;
+export declare const useExtensionPoint: <T>(id: string) => ExtensionPointStore<T> | undefined;
+export declare const useExtensionPointComponents: <T>(id: string) => Array<React.Component<T>>;
+/**
+ * ExtensionProvider houses the various locations where components from other plugins can inject
+ * functionality (such as components).
+ */
+export declare const ExtensionProvider: React.FC<ExtensionProviderProps>;
+export default ExtensionProvider;

package/dist/extensions/registry.d.ts

@@ -0,0 +1,30 @@
+import { CreateExtensionPointOptions, ExtensionPointStore, ExtensionPointSettings } from '../types/extensions';
+type CreateExtensionPointRegistryOptions = {
+    initialStores: Array<CreateExtensionPointOptions<any>>;
+};
+/**
+ * A registry for extension points.
+ */
+export declare class ExtensionPointRegistry {
+    private store;
+    constructor({ initialStores }: CreateExtensionPointRegistryOptions);
+    /**
+     * Add a new extension point to the registry. If the extension point already exists, it will not be
+     * added again.
+     * @param opts The settings for the extension point
+     */
+    addExtensionPoint<T>(opts: ExtensionPointSettings): void;
+    /**
+     * Get an extension point from the registry.
+     */
+    getExtensionPoint<T>(name: string): ExtensionPointStore<T> | undefined;
+    /**
+     * List all extension points in the registry.
+     */
+    listExtensionPointIds(): string[];
+    /**
+     * List all extensions in the registry.
+     */
+    listExtensionPoints(): ExtensionPointSettings[];
+}
+export {};

package/dist/extensions/utils.d.ts

@@ -0,0 +1,4 @@
+/**
+* Validate the extension name to ensure it matches
+*/
+export declare const validateExtensionName: (value: any) => string;

package/dist/hooks/connection/index.d.ts

@@ -0,0 +1,4 @@
+export * from './useConnection';
+export * from './useConnections';
+export * from './useConnectionNamespaces';
+export * from './useConnectionStatus';