@omniviewdev/runtime 0.9.1 → 0.10.0

package/dist/bindings/github.com/omniviewdev/omniview/backend/window/models.d.ts

@@ -0,0 +1,190 @@
+/**
+ * DragBegin starts a cross-window tab drag session.
+ */
+export declare class DragBegin {
+    "sessionId": string;
+    "sourceWindow": string;
+    "dragType": string;
+    /**
+     * Payload is the JSON of the base-ui TabDragPayload; it is forwarded to
+     * target windows verbatim.
+     */
+    "payload": string;
+    /** Creates a new DragBegin instance. */
+    constructor($$source?: Partial<DragBegin>);
+    /**
+     * Creates a new DragBegin instance from a string or object.
+     */
+    static createFrom($$source?: any): DragBegin;
+}
+/**
+ * DragBeginEvent is the payload of EventDragBegin; every window reports a
+ * fresh viewport in response.
+ */
+export declare class DragBeginEvent {
+    "sessionId": string;
+    "sourceWindow": string;
+    "dragType": string;
+    /** Creates a new DragBeginEvent instance. */
+    constructor($$source?: Partial<DragBeginEvent>);
+    /**
+     * Creates a new DragBeginEvent instance from a string or object.
+     */
+    static createFrom($$source?: any): DragBeginEvent;
+}
+/**
+ * DragEndEvent is the payload of EventDragEnd; all windows clear remote
+ * drag state for the session.
+ */
+export declare class DragEndEvent {
+    "sessionId": string;
+    /** Creates a new DragEndEvent instance. */
+    constructor($$source?: Partial<DragEndEvent>);
+    /**
+     * Creates a new DragEndEvent instance from a string or object.
+     */
+    static createFrom($$source?: any): DragEndEvent;
+}
+/**
+ * DragLeaveEvent is the payload of EventDragLeave.
+ */
+export declare class DragLeaveEvent {
+    "sessionId": string;
+    "targetWindow": string;
+    /** Creates a new DragLeaveEvent instance. */
+    constructor($$source?: Partial<DragLeaveEvent>);
+    /**
+     * Creates a new DragLeaveEvent instance from a string or object.
+     */
+    static createFrom($$source?: any): DragLeaveEvent;
+}
+/**
+ * DragPointerEvent is the payload of EventDragHover and EventDragDrop. The
+ * pointer is in the target window's client space.
+ */
+export declare class DragPointerEvent {
+    "sessionId": string;
+    "targetWindow": string;
+    /**
+     * Payload is DragBegin.Payload verbatim (JSON of TabDragPayload).
+     */
+    "payload": string;
+    "clientX": number;
+    "clientY": number;
+    /** Creates a new DragPointerEvent instance. */
+    constructor($$source?: Partial<DragPointerEvent>);
+    /**
+     * Creates a new DragPointerEvent instance from a string or object.
+     */
+    static createFrom($$source?: any): DragPointerEvent;
+}
+/**
+ * DropResult is the outcome of EndDrag.
+ */
+export declare class DropResult {
+    "accepted": boolean;
+    "targetWindow": string;
+    "targetInstanceId": string;
+    /** Creates a new DropResult instance. */
+    constructor($$source?: Partial<DropResult>);
+    /**
+     * Creates a new DropResult instance from a string or object.
+     */
+    static createFrom($$source?: any): DropResult;
+}
+/**
+ * Info describes one live window.
+ */
+export declare class Info {
+    "name": string;
+    "kind": Kind;
+    /**
+     * Focused is true for the most recently focused window.
+     */
+    "focused": boolean;
+    /** Creates a new Info instance. */
+    constructor($$source?: Partial<Info>);
+    /**
+     * Creates a new Info instance from a string or object.
+     */
+    static createFrom($$source?: any): Info;
+}
+/**
+ * Kind selects which shell a window renders.
+ */
+export declare enum Kind {
+    /**
+     * The Go zero value for the underlying type of the enum.
+     */
+    $zero = "",
+    /**
+     * KindWorkspace renders the full shell (header, rail, page tabs, panes,
+     * bottom drawer, footer).
+     */
+    KindWorkspace = "workspace",
+    /**
+     * KindPanel renders only a drawer tab strip and the drawer tab content.
+     */
+    KindPanel = "panel"
+}
+/**
+ * OpenRequest describes a window to open.
+ */
+export declare class OpenRequest {
+    "kind": Kind;
+    /**
+     * InitialState is the opaque per-slot state handed to the new window
+     * before it loads (same format as SaveState slots).
+     */
+    "initialState": {
+        [_ in string]?: string;
+    };
+    /**
+     * When HasPosition is set the new window's top-left is placed near the
+     * pointer at (ClientX, ClientY) in AnchorWindow's client space.
+     */
+    "anchorWindow": string;
+    "clientX": number;
+    "clientY": number;
+    "hasPosition": boolean;
+    /**
+     * Width and Height of the new window; 0 selects the kind's default.
+     */
+    "width": number;
+    "height": number;
+    /** Creates a new OpenRequest instance. */
+    constructor($$source?: Partial<OpenRequest>);
+    /**
+     * Creates a new OpenRequest instance from a string or object.
+     */
+    static createFrom($$source?: any): OpenRequest;
+}
+/**
+ * WindowClosedEvent is the payload of EventWindowClosed. States holds the
+ * closed window's last saved slots (slot -> JSON).
+ */
+export declare class WindowClosedEvent {
+    "name": string;
+    "kind": Kind;
+    "states": {
+        [_ in string]?: string;
+    };
+    /** Creates a new WindowClosedEvent instance. */
+    constructor($$source?: Partial<WindowClosedEvent>);
+    /**
+     * Creates a new WindowClosedEvent instance from a string or object.
+     */
+    static createFrom($$source?: any): WindowClosedEvent;
+}
+/**
+ * WindowsChangedEvent is the payload of EventWindowsChanged.
+ */
+export declare class WindowsChangedEvent {
+    "windows": Info[];
+    /** Creates a new WindowsChangedEvent instance. */
+    constructor($$source?: Partial<WindowsChangedEvent>);
+    /**
+     * Creates a new WindowsChangedEvent instance from a string or object.
+     */
+    static createFrom($$source?: any): WindowsChangedEvent;
+}

package/dist/bindings/github.com/omniviewdev/omniview/backend/window/service.d.ts

@@ -0,0 +1,83 @@
+import { CancellablePromise as $CancellablePromise } from '@wailsio/runtime';
+import * as $models from "./models.js";
+/**
+ * BeginDrag starts a cross-window drag owned by the source window, refreshes
+ * every window's native bounds and asks every window to report a fresh
+ * viewport.
+ */
+export declare function BeginDrag(b: $models.DragBegin): $CancellablePromise<void>;
+/**
+ * CancelDrag ends a session without a drop. Unknown sessions are ignored.
+ */
+export declare function CancelDrag(sessionID: string): $CancellablePromise<void>;
+/**
+ * Close closes a non-main window. Its state is removed and windows/closed is
+ * emitted once the OS window has closed.
+ */
+export declare function Close(name: string): $CancellablePromise<void>;
+/**
+ * EndDrag drops the tab on the window under the pointer (given in the source
+ * window's client space) and waits for that window's RespondDrop. It returns
+ * a not-accepted result when no other window is under the pointer, the
+ * target declines, closes, or does not answer in time. The session always
+ * ends with windows/drag/end.
+ */
+export declare function EndDrag(sessionID: string, clientX: number, clientY: number): $CancellablePromise<$models.DropResult>;
+/**
+ * Focus shows, restores and focuses the named window.
+ */
+export declare function Focus(name: string): $CancellablePromise<void>;
+/**
+ * GetState returns the named window's slots (slot -> JSON). A window calls it
+ * once its frontend has loaded, which also releases the next queued restore.
+ */
+export declare function GetState(name: string): $CancellablePromise<{
+    [_ in string]?: string;
+}>;
+/**
+ * List returns the live windows in creation order.
+ */
+export declare function List(): $CancellablePromise<$models.Info[]>;
+/**
+ * ListStates returns every live window's slots (window -> slot -> JSON).
+ */
+export declare function ListStates(): $CancellablePromise<{
+    [_ in string]?: {
+        [_ in string]?: string;
+    };
+}>;
+/**
+ * MoveDrag routes the pointer, given in the source window's client space, to
+ * the window under it: the previous target gets a leave event, the current
+ * target a hover event. Moves for unknown or ending sessions are ignored;
+ * they race with EndDrag/CancelDrag by design.
+ */
+export declare function MoveDrag(sessionID: string, clientX: number, clientY: number): $CancellablePromise<void>;
+/**
+ * MoveToPointer places the named window like a torn-off tab: its top-left
+ * goes up/left of the pointer, which is given in the window's own client
+ * space.
+ */
+export declare function MoveToPointer(name: string, clientX: number, clientY: number): $CancellablePromise<void>;
+/**
+ * Open creates a window of the requested kind and returns its name. The
+ * InitialState slots are served by GetState before the window loads.
+ */
+export declare function Open(req: $models.OpenRequest): $CancellablePromise<string>;
+/**
+ * ReportViewport records the named window's webview viewport size in CSS
+ * px. Together with the native bounds it locates the window's content on
+ * screen for drag hit-testing. Reports from unknown windows (for example a
+ * window that just closed) are ignored.
+ */
+export declare function ReportViewport(name: string, width: number, height: number): $CancellablePromise<void>;
+/**
+ * RespondDrop delivers the drop target's answer to the waiting EndDrag.
+ * Answers for unknown sessions, sessions not waiting on a drop, and duplicate
+ * answers are ignored.
+ */
+export declare function RespondDrop(sessionID: string, accepted: boolean, targetInstanceID: string): $CancellablePromise<void>;
+/**
+ * SaveState stores one slot of the named window and schedules persistence.
+ */
+export declare function SaveState(name: string, slot: string, stateJSON: string): $CancellablePromise<void>;

package/dist/connection/ConnectionBoundary.d.ts

@@ -0,0 +1,21 @@
+import { default as React, ReactNode } from 'react';
+import { ConnectionReadiness } from '../hooks/connection/useConnectionReadiness';
+export interface ConnectionBoundaryProps {
+    pluginID?: string;
+    connectionID: string;
+    children: ReactNode;
+    fallback?: (state: ConnectionReadiness) => ReactNode;
+}
+export interface ConnectionBoundaryFallbackProps {
+    state: ConnectionReadiness;
+    connectionName?: string;
+    /** Plugin-provided connection identity, shown above status instead of the generic connection name. */
+    connectionDetails?: ReactNode;
+    onEditConnection?: () => void;
+    onBack?: () => void;
+    backLabel?: string;
+}
+/** Presentation only: no connection requests or automatic recovery. */
+export declare function ConnectionBoundaryFallback({ state, connectionName, connectionDetails, onEditConnection, onBack, backLabel }: ConnectionBoundaryFallbackProps): React.JSX.Element | null;
+/** Mount children only after the backend confirms this connection is connected. */
+export declare function ConnectionBoundary(props: ConnectionBoundaryProps): React.JSX.Element;

package/dist/connection/connectionReadiness.d.ts

@@ -0,0 +1,30 @@
+import { Connection, ConnectionStatus } from '../bindings/github.com/omniviewdev/plugin-sdk/pkg/types/models';
+export type ConnectionReadinessPhase = 'checking' | 'disconnected' | 'connecting' | 'connected' | 'unauthorized' | 'forbidden' | 'not-found' | 'error';
+export interface ConnectionReadiness {
+    phase: ConnectionReadinessPhase;
+    message?: string;
+    connection?: Connection;
+    connect: () => Promise<void>;
+    retry: () => Promise<void>;
+}
+type Snapshot = Pick<ConnectionReadiness, 'phase' | 'message' | 'connection'>;
+/** Internal hook adapter. Inactive snapshots never reuse an earlier mount's readiness. */
+export declare function connectionReadinessStore(pluginID: string, connectionID: string): {
+    getSnapshot: () => Snapshot;
+    subscribe: (listener: () => void) => () => void;
+    connect: () => Promise<void>;
+    retry: () => Promise<void>;
+};
+/** Check connection readiness before non-React I/O. This never starts a connection. */
+export declare function requireConnectionReady(pluginID: string, connectionID: string): Promise<void>;
+/** Keep lifecycle events observed until I/O completes, then reject invalidated results. */
+export declare function withConnectionReady<T>(pluginID: string, connectionID: string, operation: () => Promise<T>): Promise<T>;
+/** Internal resource-I/O fence; reading does not create or retain a store entry. */
+export declare function getConnectionReadinessGeneration(pluginID: string, connectionID: string): number | undefined;
+export declare function isConnectionReadinessCurrent(pluginID: string, connectionID: string, expectedGeneration: number | undefined): boolean;
+/** Preserve useConnection's status return value while sharing explicit starts. */
+export declare function startConnectionWithReadiness(pluginID: string, connectionID: string): Promise<ConnectionStatus>;
+/** Block consumers immediately, including while a previous check/start is pending. */
+export declare function stopConnectionWithReadiness(pluginID: string, connectionID: string): Promise<Connection>;
+export declare function invalidateConnectionReadiness(pluginID: string, connectionID: string, removed?: boolean): void;
+export {};

package/dist/context/index.d.ts

@@ -3,3 +3,4 @@ export * from './settings';
 export * from './drawer';
 export * from './modal';
 export * from './operations/OperationsContext';
+export * from './windows';

package/dist/context/windows/WindowActionsContext.d.ts

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+export type OpenInNewTabOptions = {
+    /** Keep the current tab active; the new tab opens behind it. */
+    background?: boolean;
+};
+/**
+ * Opens host routes (e.g. `/_plugin/kubernetes/cluster/abc/resources`) outside
+ * the current page tab. The host application provides the implementation.
+ */
+export type WindowActions = {
+    /** Opens the path in a new page tab next to the current one. */
+    openInNewTab: (path: string, options?: OpenInNewTabOptions) => void;
+    /** Opens the path in a new workspace window. */
+    openInNewWindow: (path: string) => void;
+    /** Opens the path in a new tab in the side-by-side pane, splitting the view if needed. */
+    openInSplit: (path: string) => void;
+};
+export declare const WindowActionsContext: React.Context<WindowActions | null>;
+export declare const WindowActionsProvider: React.FC<{
+    actions: WindowActions;
+    children: React.ReactNode;
+}>;
+/**
+ * Window-level navigation for plugins: open a route in a new tab, a new window
+ * or the split pane.
+ *
+ * @example
+ * const { openInNewTab } = useWindowActions();
+ * openInNewTab(`/_plugin/${pluginId}/cluster/${id}/resources`);
+ */
+export declare function useWindowActions(): WindowActions;

package/dist/context/windows/activePageNavigator.d.ts

@@ -0,0 +1,13 @@
+type ActivePageNavigator = (path: string) => void;
+/**
+ * The host registers how to navigate the page the user is looking at (the
+ * active page tab of this window). Returns the unregister function.
+ */
+export declare function registerActivePageNavigator(navigator: ActivePageNavigator): () => void;
+/**
+ * Navigates the active page of this window to a host route such as
+ * `/settings?category=developer`. Code outside React (error actions, event
+ * handlers) uses this instead of touching `window.location`.
+ */
+export declare function navigateActivePage(path: string): void;
+export {};

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

@@ -0,0 +1,2 @@
+export * from './WindowActionsContext';
+export * from './activePageNavigator';

package/dist/extensions/provider.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { ExtensionPointRegistryContract, ExtensionPointStoreContract, ExtensionRenderContext } from '../types/extensions';
+import { ExtensionContributionRegistration, ExtensionPointRegistryContract, ExtensionPointStoreContract, ExtensionRenderContext } from '../types/extensions';
 type ExtensionProviderProps = {
     /** Allow passing in a custom registry, purely for testing purposes */
     registry: ExtensionPointRegistryContract;
@@ -7,14 +7,14 @@ type ExtensionProviderProps = {
 };
 export type ExtensionProviderType = React.FC<ExtensionProviderProps>;
 export declare const useExtensionRegistry: () => ExtensionPointRegistryContract | undefined;
-/**
- * Hook to get an extension point store that reactively updates when contributions change.
- * Mounted consumers rerender when matching registry data changes.
- *
- * Uses a sentinel-based snapshot so that useSyncExternalStore detects contribution
- * mutations even though the store object reference is stable. The store exposes a
- * monotonically increasing `version` counter that increments on every register/unregister.
- */
+export interface ExtensionPointSnapshot<TValue = unknown, TContext = ExtensionRenderContext> {
+    readonly store: ExtensionPointStoreContract<TValue, TContext> | undefined;
+    readonly version: number;
+    readonly contributions: readonly ExtensionContributionRegistration<TValue>[];
+}
+/** Immutable render input; a stable mutable store is not a React Compiler dependency. */
+export declare function useExtensionPointSnapshot<TValue = unknown, TContext = ExtensionRenderContext>(id: string): ExtensionPointSnapshot<TValue, TContext>;
+/** Access the live store for imperative matching and registration. */
 export declare function useExtensionPoint<TValue = unknown, TContext = ExtensionRenderContext>(id: string): ExtensionPointStoreContract<TValue, TContext> | undefined;
 /**
  * ExtensionProvider houses the various locations where components from other plugins can inject

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

@@ -2,3 +2,7 @@ export * from './useConnection';
 export * from './useConnections';
 export * from './useConnectionNamespaces';
 export * from './useConnectionStatus';
+export * from './useConnectionReadiness';
+export { requireConnectionReady, withConnectionReady } from '../../connection/connectionReadiness';
+export { ConnectionBoundary, ConnectionBoundaryFallback } from '../../connection/ConnectionBoundary';
+export type { ConnectionBoundaryProps, ConnectionBoundaryFallbackProps } from '../../connection/ConnectionBoundary';

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

@@ -7,11 +7,12 @@ type UseConnectionOptions = {
      * The ID of the connection
      */
     connectionID: string;
+    enabled?: boolean;
 };
 /**
  * Get and retreive connections from a plugin's connection manager..
  */
-export declare const useConnectionNamespaces: ({ pluginID: explicitPluginID, connectionID }: UseConnectionOptions) => {
+export declare const useConnectionNamespaces: ({ pluginID: explicitPluginID, connectionID, enabled }: UseConnectionOptions) => {
     /**
      * Get the connection
      */

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

@@ -0,0 +1,9 @@
+import { ConnectionReadiness } from '../../connection/connectionReadiness';
+export type { ConnectionReadiness, ConnectionReadinessPhase } from '../../connection/connectionReadiness';
+export interface UseConnectionReadinessOptions {
+    pluginID?: string;
+    connectionID: string;
+    enabled?: boolean;
+}
+/** Readiness is independent of resource-watch synchronization and never auto-connects. */
+export declare function useConnectionReadiness({ pluginID: explicitPluginID, connectionID, enabled, }: UseConnectionReadinessOptions): ConnectionReadiness;

package/dist/hooks/resource/useConnectionQueryGuard.d.ts

@@ -0,0 +1,3 @@
+import { QueryKey } from '@tanstack/react-query';
+/** Cancel connection-scoped reads immediately and reject late results after invalidation. */
+export declare function useConnectionQueryGuard(pluginID: string, connectionID: string): <T>(queryKey: QueryKey, signal: AbortSignal, operation: () => Promise<T>) => Promise<T>;

package/dist/hooks/resource/useEventBatcher.d.ts

@@ -56,4 +56,5 @@ export declare function applyBatch(oldData: any, events: ResourceEvent[], idAcce
  */
 export declare function useEventBatcher(queryClient: QueryClient, queryKey: QueryKey, getResourceKey: (id: string, ns: string) => QueryKey, idAccessor: string | undefined, watchState: WatchState, options?: {
     syncWindowMs?: number;
+    enabled?: boolean;
 }): (event: ResourceEvent) => void;

package/dist/hooks/resource/useResource.d.ts

@@ -25,6 +25,7 @@ type UseResourceOptions = {
      * @example "default"
      */
     namespace?: string;
+    enabled?: boolean;
 };
 /**
  * The useResource hook returns a hook, scoped to the desired resource and connection, that allows for interacting
@@ -33,7 +34,7 @@ type UseResourceOptions = {
  * It should be noted that this hook does not perform any logic to ensure that either the resource exists,
  * @throws If the resourceID is invalid
  */
-export declare const useResource: ({ pluginID: explicitPluginID, connectionID, resourceKey, resourceID, namespace, }: UseResourceOptions) => {
+export declare const useResource: ({ pluginID: explicitPluginID, connectionID, resourceKey, resourceID, namespace, enabled, }: UseResourceOptions) => {
     /**
      * Fetch result for the resource. The client will automatically cache the result, and update the cache
      * when the resource is updated or deleted via the returned update and remove mutation functions.
@@ -46,7 +47,7 @@ export declare const useResource: ({ pluginID: explicitPluginID, connectionID, r
      * @params opts Optional parameters to pass to the resource update
      */
     update: import('@tanstack/react-query').UseMutateAsyncFunction<import('../../models').UpdateResult | null, unknown, {
-        input?: any;
+        input?: unknown;
     }, unknown>;
     /**
      * Delete an existing resource. A set of optional parameters can be passed to customize the delete behavior,

package/dist/hooks/resource/useResourceGroups.d.ts

@@ -7,11 +7,12 @@ type UseResourceGroupsOptions = {
      * The ID of the connection
      */
     connectionID: string;
+    enabled?: boolean;
 };
 /**
  * Fetch the resource groups for a given plugin and connection.
  */
-export declare const useResourceGroups: ({ pluginID: explicitPluginID, connectionID }: UseResourceGroupsOptions) => {
+export declare const useResourceGroups: ({ pluginID: explicitPluginID, connectionID, enabled }: UseResourceGroupsOptions) => {
     /**
      * The resource groups for the given plugin and connection.
      */

package/dist/hooks/resource/useResourceMutations.d.ts

@@ -44,14 +44,14 @@ export declare const useResourceMutations: ({ pluginID: explicitPluginID }: UseR
     create: import('@tanstack/react-query').UseMutateAsyncFunction<import('../../models').CreateResult | null, unknown, {
         opts: ResourceMutationOptions;
         input: {
-            input?: any;
+            input?: unknown;
             namespace?: string;
         };
     }, unknown>;
     update: import('@tanstack/react-query').UseMutateAsyncFunction<import('../../models').UpdateResult | null, unknown, {
         opts: ResourceMutationOptions;
         input: {
-            input?: any;
+            input?: unknown;
         };
     }, unknown>;
     remove: import('@tanstack/react-query').UseMutateAsyncFunction<import('../../models').DeleteResult | null, unknown, {

package/dist/hooks/resource/useResourceSearch.d.ts

@@ -13,6 +13,7 @@ type UseResourceSearchOptions = {
      * Entry for the resource search
      */
     searches: ResourceSearchEntry[];
+    enabled?: boolean;
 };
 type ResourceSearchEntry = {
     /**
@@ -32,5 +33,5 @@ type ResourceSearchEntry = {
  * The useResourceSearch is a utility hook to search across multiple resources and/or namespaces. This hook is currently
  * limited searching within a single plugin, and a single connection.
  */
-export declare const useResourceSearch: ({ pluginID: explicitPluginID, connectionID, searches, }: UseResourceSearchOptions) => import('@tanstack/react-query').UseQueryResult<any[], Error>[];
+export declare const useResourceSearch: ({ pluginID: explicitPluginID, connectionID, searches, enabled, }: UseResourceSearchOptions) => import('@tanstack/react-query').UseQueryResult<any[], Error>[];
 export default useResourceSearch;

package/dist/hooks/resource/useResourceTypes.d.ts

@@ -7,11 +7,12 @@ type UseResourceTypesOptions = {
     * The ID of the connection
     */
     connectionID: string;
+    enabled?: boolean;
 };
 /**
  * Fetch the resource types for a given plugin and connection.
  */
-export declare const useResourceTypes: ({ pluginID: explicitPluginID, connectionID }: UseResourceTypesOptions) => {
+export declare const useResourceTypes: ({ pluginID: explicitPluginID, connectionID, enabled }: UseResourceTypesOptions) => {
     /**
      * The resource types for the given plugin and connection.
      */

package/dist/hooks/resource/useResources.d.ts

@@ -27,6 +27,7 @@ type UseResourcesOptions = {
      * live functionality to work, this must be set to the path on which the ID is located.
      */
     idAccessor?: string;
+    enabled?: boolean;
 };
 /**
  * The useResource hook returns a hook, scoped to the desired resource and connection, that allows for interacting
@@ -35,7 +36,7 @@ type UseResourcesOptions = {
  * It should be noted that this hook does not perform any logic to ensure that either the resource exists,
  * @throws If the resourceID is invalid
  */
-export declare const useResources: ({ pluginID: explicitPluginID, connectionID, resourceKey, idAccessor, namespaces, }: UseResourcesOptions) => {
+export declare const useResources: ({ pluginID: explicitPluginID, connectionID, resourceKey, idAccessor, namespaces, enabled, }: UseResourcesOptions) => {
     /**
      * Fetch result for the resource. The client will automatically cache the result, and update the cache
      * when the resources are updated or deleted via the returned create and remove mutation functions, or
@@ -49,7 +50,7 @@ export declare const useResources: ({ pluginID: explicitPluginID, connectionID,
      * @params opts Optional parameters to pass to the resource create operation
      */
     create: import('@tanstack/react-query').UseMutateAsyncFunction<import('../../models').CreateResult | null, unknown, {
-        input?: any;
+        input?: unknown;
         namespace?: string;
     }, unknown>;
     /** Current watch state for this resource type */