@omniviewdev/runtime 0.0.0-nightly.20260225

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

@@ -0,0 +1,37 @@
+import { types } from '../../wailsjs/go/models';
+type UseConnectionOptions = {
+    /**
+     * The name of the plugin we're interacting with
+     */
+    pluginID?: string;
+    /**
+     * The ID of the connection
+     */
+    connectionID: string;
+};
+/**
+ * Get and retreive connections from a plugin's connection manager..
+ */
+export declare const useConnection: ({ pluginID: explicitPluginID, connectionID }: UseConnectionOptions) => {
+    /**
+     * Get the connection
+     */
+    connection: import('@tanstack/react-query').UseQueryResult<types.Connection, Error>;
+    /**
+     * Start the connection
+     */
+    startConnection: import('@tanstack/react-query').UseMutateAsyncFunction<types.ConnectionStatus, unknown, void, unknown>;
+    /**
+     * Stop the connection
+     */
+    stopConnection: import('@tanstack/react-query').UseMutateAsyncFunction<types.Connection, unknown, void, unknown>;
+    /**
+     * Update the connection.
+     */
+    updateConnection: import('@tanstack/react-query').UseMutateAsyncFunction<types.Connection, unknown, types.Connection, unknown>;
+    /**
+     * Delete the connection
+     */
+    deleteConnection: import('@tanstack/react-query').UseMutateAsyncFunction<void, unknown, void, unknown>;
+};
+export {};

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

@@ -0,0 +1,20 @@
+type UseConnectionOptions = {
+    /**
+     * The name of the plugin we're interacting with
+     */
+    pluginID?: string;
+    /**
+     * The ID of the connection
+     */
+    connectionID: string;
+};
+/**
+ * Get and retreive connections from a plugin's connection manager..
+ */
+export declare const useConnectionNamespaces: ({ pluginID: explicitPluginID, connectionID }: UseConnectionOptions) => {
+    /**
+     * Get the connection
+     */
+    namespaces: import('@tanstack/react-query').UseQueryResult<string[], Error>;
+};
+export {};

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

@@ -0,0 +1,29 @@
+import { ActiveSync } from '../../utils/activeSyncAggregator';
+export interface ConnectionStatusEntry {
+    pluginID: string;
+    connectionID: string;
+    name: string;
+    avatar: string;
+    isStarted: boolean;
+    sync?: ActiveSync;
+    isSyncing: boolean;
+    hasErrors: boolean;
+}
+export interface ConnectionStatusSummary {
+    entries: ConnectionStatusEntry[];
+    grouped: Map<string, ConnectionStatusEntry[]>;
+    connectedCount: number;
+    syncingCount: number;
+    errorCount: number;
+    hasSyncing: boolean;
+    aggregateProgress: number;
+    /** Disconnect a connection by plugin/connection ID */
+    disconnect: (pluginID: string, connectionID: string) => Promise<void>;
+    /** Retry informer sync for a connection */
+    retryInformer: (pluginID: string, connectionID: string) => Promise<void>;
+}
+/**
+ * Unified hook that tracks connection status across all plugins.
+ * Combines ListAllConnections query + connection/status events + informer/STATE events.
+ */
+export declare function useConnectionStatus(): ConnectionStatusSummary;

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

@@ -0,0 +1,18 @@
+import { types } from '../../wailsjs/go/models';
+type UseConnectionsOptions = {
+    /**
+    * The name of the plugin we're interacting with
+    */
+    plugin?: string;
+};
+/** Stable query key factory for connection list queries. */
+export declare const connectionListQueryKey: (plugin: string) => string[];
+/**
+* Get and retreive connections from a plugin's connection manager..
+ */
+export declare const useConnections: ({ plugin: explicitPlugin }: UseConnectionsOptions) => {
+    connections: import('@tanstack/react-query').UseQueryResult<types.Connection[], Error>;
+    startInformer: import('@tanstack/react-query').UseMutateAsyncFunction<void, unknown, types.Connection, unknown>;
+    stopInformer: import('@tanstack/react-query').UseMutateAsyncFunction<void, unknown, types.Connection, unknown>;
+};
+export {};

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

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

package/dist/hooks/data/usePluginData.d.ts

@@ -0,0 +1,11 @@
+type UsePluginDataResult<T> = {
+    data: T;
+    update: (value: T) => Promise<void>;
+    isLoading: boolean;
+};
+/**
+ * Generic hook for reading/writing plugin data from the Plugin Data Store.
+ * Uses React Query for caching and optimistic updates.
+ */
+export declare function usePluginData<T>(explicitPluginID: string | undefined, key: string, defaultValue: T): UsePluginDataResult<T>;
+export {};

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

@@ -0,0 +1,2 @@
+export * from './useRightDrawer';
+export * from './useBottomDrawer';

package/dist/hooks/drawer/useBottomDrawer.d.ts

@@ -0,0 +1 @@
+export declare const useBottomDrawer: () => import('../..').BottomDrawerContextType;

package/dist/hooks/drawer/useRightDrawer.d.ts

@@ -0,0 +1,5 @@
+import { RightDrawerContextType } from '../../context/drawer/RightDrawerContext';
+/**
+ * Display a component within the right-side application drawer
+ */
+export declare const useRightDrawer: () => RightDrawerContextType;

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

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

package/dist/hooks/exec/useExecSession.d.ts

@@ -0,0 +1,21 @@
+import { exec } from '../../wailsjs/go/models';
+type UseResourceMutationsOptions = {
+    /**
+     * The ID of the plugin responsible for this resource
+     * @example "kubernetes"
+     */
+    pluginID?: string;
+};
+type CreateSessionOptions = {
+    connectionID: string;
+    icon?: string | React.ReactNode;
+    label?: string;
+    opts: Partial<exec.SessionOptions>;
+};
+/**
+ * Create or manage sessions from throughout the app
+ */
+export declare const useExec: ({ pluginID: explicitPluginID }: UseResourceMutationsOptions) => {
+    createSession: import('@tanstack/react-query').UseMutateAsyncFunction<void, Error, CreateSessionOptions, unknown>;
+};
+export default useExec;

package/dist/hooks/index.d.ts

@@ -0,0 +1,13 @@
+export * from './connection';
+export * from './data';
+export * from './drawer';
+export * from './exec';
+export * from './logs';
+export * from './metric';
+export * from './networker';
+export * from './modal';
+export * from './resource';
+export * from './settings';
+export * from './snackbar';
+export * from './operations/useOperations';
+export * from './useResolvedPluginId';

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

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

package/dist/hooks/logs/useLogSession.d.ts

@@ -0,0 +1,21 @@
+import { logs } from '../../wailsjs/go/models';
+type UseLogSessionOptions = {
+    pluginID?: string;
+};
+type CreateLogSessionArgs = {
+    connectionID: string;
+    resourceKey: string;
+    resourceID: string;
+    resourceData: Record<string, any>;
+    icon?: string | React.ReactNode;
+    label?: string;
+    target?: string;
+    follow?: boolean;
+    tailLines?: number;
+    params?: Record<string, string>;
+};
+export declare const useLogs: ({ pluginID: explicitPluginID }: UseLogSessionOptions) => {
+    createLogSession: import('@tanstack/react-query').UseMutateAsyncFunction<logs.LogSession, unknown, CreateLogSessionArgs, unknown>;
+    closeLogSession: import('@tanstack/react-query').UseMutateAsyncFunction<void, unknown, string, unknown>;
+};
+export default useLogs;

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

@@ -0,0 +1,3 @@
+export * from './useMetricProviders';
+export * from './useResourceMetrics';
+export * from './useMetricStream';

package/dist/hooks/metric/useMetricProviders.d.ts

@@ -0,0 +1,9 @@
+import { metric } from '../../wailsjs/go/models';
+/**
+ * Hook to get all available metric providers.
+ */
+export declare const useMetricProviders: () => import('@tanstack/react-query').UseQueryResult<metric.MetricProviderSummary[], Error>;
+/**
+ * Hook to get metric providers that support a specific resource type.
+ */
+export declare const useMetricProvidersForResource: (resourceKey: string) => import('@tanstack/react-query').UseQueryResult<metric.MetricProviderSummary[], Error>;

package/dist/hooks/metric/useMetricStream.d.ts

@@ -0,0 +1,40 @@
+import { metric } from '../../wailsjs/go/models';
+export type UseMetricStreamOptions = {
+    /** The plugin providing metrics */
+    pluginID?: string;
+    /** The connection to stream metrics for */
+    connectionID: string;
+    /** The resource type key */
+    resourceKey: string;
+    /** The resource instance ID */
+    resourceID: string;
+    /** The resource namespace */
+    resourceNamespace?: string;
+    /** The full resource data object */
+    resourceData?: Record<string, unknown>;
+    /** Specific metric IDs to stream */
+    metricIDs?: string[];
+    /** Polling interval in milliseconds (default 10000) */
+    interval?: number;
+    /** Whether the stream is enabled */
+    enabled?: boolean;
+};
+export type UseMetricStreamResult = {
+    /** The latest stream output */
+    data: metric.MetricResult[] | null;
+    /** The subscription ID */
+    subscriptionID: string | null;
+    /** Whether the stream is active */
+    isStreaming: boolean;
+    /** Error from the stream */
+    error: string | null;
+    /** Start the stream */
+    start: () => Promise<void>;
+    /** Stop the stream */
+    stop: () => Promise<void>;
+};
+/**
+ * Hook to subscribe to a real-time metric stream from a specific provider.
+ * Uses Wails events for push-based data.
+ */
+export declare const useMetricStream: (opts: UseMetricStreamOptions) => UseMetricStreamResult;

package/dist/hooks/metric/useResourceMetrics.d.ts

@@ -0,0 +1,46 @@
+import { metric } from '../../wailsjs/go/models';
+export type UseResourceMetricsOptions = {
+    /** The plugin that owns the resource (e.g., "kubernetes") */
+    pluginID?: string;
+    /** The connection to query metrics for */
+    connectionID: string;
+    /** The resource type key (e.g., "core::v1::Pod") */
+    resourceKey: string;
+    /** The resource instance ID (e.g., pod name) */
+    resourceID: string;
+    /** The resource namespace (optional) */
+    resourceNamespace?: string;
+    /** The full resource data object */
+    resourceData?: Record<string, unknown>;
+    /** Specific metric IDs to fetch (empty = all) */
+    metricIDs?: string[];
+    /** The shape of metric data to request */
+    shape?: number;
+    /** Time range for timeseries data */
+    timeRange?: {
+        start: Date;
+        end: Date;
+        step: string;
+    };
+    /** Auto-refresh interval in milliseconds (0 = disabled) */
+    refreshInterval?: number;
+    /** Whether the query is enabled */
+    enabled?: boolean;
+};
+export type UseResourceMetricsResult = {
+    /** Metric results keyed by provider plugin ID */
+    data: Record<string, metric.QueryResponse> | undefined;
+    /** Available metric providers for this resource type */
+    providers: metric.MetricProviderSummary[];
+    /** Whether any query is currently loading */
+    isLoading: boolean;
+    /** Error from the query, if any */
+    error: Error | null;
+    /** Manually refetch metrics */
+    refetch: () => void;
+};
+/**
+ * Hook to query metrics from all available providers for a resource.
+ * Automatically discovers providers and aggregates results.
+ */
+export declare const useResourceMetrics: (opts: UseResourceMetricsOptions) => UseResourceMetricsResult;

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

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

package/dist/hooks/modal/useConfirmationModal.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Display a modal to confirm an action from the user before running the callback
+ * function.
+ */
+export declare const useConfirmationModal: () => import('../..').ConfirmationModalContextType;

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

@@ -0,0 +1,3 @@
+export * from './usePortForwardSessions';
+export * from './useResourcePortForwarder';
+export * from './types';

package/dist/hooks/networker/types.d.ts

@@ -0,0 +1,50 @@
+import { networker } from '../../models';
+export type PortForwardResourceOpts = {
+    /**
+    * The resource key identifier.
+    * For example, the Kubernetes plugin supports the following resource keys:
+    * - 'core::v1::Pod'
+    */
+    resourceKey: string;
+    /**
+    * The resource ID
+    */
+    resourceId: string;
+    /**
+    * The resource data object
+    */
+    resource: any;
+    /**
+    * The port to forward on the resource
+    * @example 8080
+    */
+    remotePort: number;
+    /**
+    * The port on the host to forward to. If none is provided, a random port will be assigned.
+    * Note: If specifying, it is highly advised to use a port in the range 30000-32767
+    * @example 31234
+    */
+    localPort?: number;
+    /**
+    * The protocol to forward. Default is TCP.
+    */
+    protocol?: 'TCP' | 'UDP';
+    /**
+    * Parameters to pass to the resource to configure the port forward.
+    */
+    parameters?: Record<string, string>;
+    /**
+    * Whether to open the forwarded port in the default browser. Default is false.
+    */
+    openInBrowser?: boolean;
+    /**
+    * Optional labels to apply to the port forward session.
+    */
+    labels?: Record<string, string>;
+};
+export type PortForwardResourceFunction = (opts: PortForwardResourceOpts) => Promise<networker.PortForwardSession>;
+export type ResourcePortForwarder = {
+    sessions: networker.PortForwardSession[];
+    forward: PortForwardResourceFunction;
+    close: (sessionId: string) => Promise<void>;
+};

package/dist/hooks/networker/usePortForwardSessions.d.ts

@@ -0,0 +1,13 @@
+declare const ALL_SESSIONS_KEY: readonly ["networker", "portforward", "all-sessions"];
+/**
+ * Global hook providing a view of all active port-forward sessions across all plugins.
+ * Listens to Wails events for real-time updates instead of polling.
+ */
+export declare function usePortForwardSessions(): {
+    sessions: import('@tanstack/react-query').UseQueryResult<never[] | import("../../models").networker.PortForwardSession[], Error>;
+    activeSessions: import("../../models").networker.PortForwardSession[];
+    closeSession: import('@tanstack/react-query').UseMutateAsyncFunction<import("../../models").networker.PortForwardSession, unknown, string, unknown>;
+    openInBrowser: (localPort: number) => void;
+};
+export { ALL_SESSIONS_KEY };
+export default usePortForwardSessions;

package/dist/hooks/networker/useResourcePortForwarder.d.ts

@@ -0,0 +1,21 @@
+import { PortForwardResourceOpts } from './types';
+import { networker } from '../../wailsjs/go/models';
+/**
+* Programatically forward a port from a resource object to the host.
+*/
+export declare function useResourcePortForwarder({ pluginID: explicitPluginID, connectionID, resourceID }: {
+    pluginID?: string;
+    connectionID: string;
+    resourceID: string;
+}): {
+    sessions: import('@tanstack/react-query').UseQueryResult<never[] | networker.PortForwardSession[], Error>;
+    forward: import('@tanstack/react-query').UseMutateAsyncFunction<networker.PortForwardSession, unknown, {
+        opts: Partial<PortForwardResourceOpts>;
+    }, unknown>;
+    close: import('@tanstack/react-query').UseMutateAsyncFunction<networker.PortForwardSession, unknown, {
+        opts: {
+            sessionID: string;
+        };
+    }, unknown>;
+};
+export default useResourcePortForwarder;

package/dist/hooks/operations/useOperations.d.ts

@@ -0,0 +1 @@
+export declare const useOperations: () => import('../..').OperationsContextType;

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

@@ -0,0 +1,13 @@
+export * from './useResource';
+export * from './useResourceAreaComponent';
+export * from './useResourceGroups';
+export * from './useResourceSearch';
+export * from './useResourceType';
+export * from './useResourceTypes';
+export * from './useResources';
+export * from './useResourceMutations';
+export * from './useResourceActions';
+export * from './useEditorSchemas';
+export * from './useInformerState';
+export * from './useActiveSyncs';
+export * from './useStreamAction';

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

@@ -0,0 +1,16 @@
+import { ActiveSync } from '../../utils/activeSyncAggregator';
+export type { ActiveSync };
+/**
+ * useActiveSyncs aggregates informer sync state across all connections.
+ * Subscribes to the global `informer/STATE` event topic.
+ */
+export declare const useActiveSyncs: () => {
+    /** All tracked syncs */
+    syncs: ActiveSync[];
+    /** Whether any connection is actively syncing */
+    hasSyncing: boolean;
+    /** The primary (first incomplete) sync or most recent */
+    primarySync: ActiveSync;
+    /** Aggregate progress across all connections (0-1) */
+    aggregateProgress: number;
+};

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

@@ -0,0 +1,22 @@
+type UseEditorSchemasOptions = {
+    /** The plugin ID to fetch schemas for */
+    pluginID?: string;
+    /** The connection ID to fetch schemas for */
+    connectionID: string;
+    /** Whether to enable the query */
+    enabled?: boolean;
+};
+/**
+ * useEditorSchemas fetches editor schemas for a plugin + connection pair
+ * from the backend via Wails bindings.
+ *
+ * The caller is responsible for registering the returned schemas with
+ * the SchemaRegistry (which lives in the host app's monaco provider).
+ */
+export declare const useEditorSchemas: ({ pluginID: explicitPluginID, connectionID, enabled, }: UseEditorSchemasOptions) => {
+    schemas: import("../../models").types.EditorSchema[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import("../../models").types.EditorSchema[], Error>>;
+};
+export default useEditorSchemas;

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

@@ -0,0 +1,24 @@
+import { InformerConnectionSummary, InformerResourceState } from '../../types/informer';
+type UseInformerStateOptions = {
+    pluginID?: string;
+    connectionID: string;
+    enabled?: boolean;
+};
+/**
+ * useInformerState provides real-time informer state for a connection.
+ * It fetches the initial summary via Wails binding and subscribes to
+ * state change events for live updates.
+ */
+export declare const useInformerState: ({ pluginID: explicitPluginID, connectionID, enabled, }: UseInformerStateOptions) => {
+    /** Full summary query result */
+    summary: import('@tanstack/react-query').UseQueryResult<InformerConnectionSummary, Error>;
+    /** Get the state of a specific resource type's informer */
+    getResourceState: (key: string) => InformerResourceState | undefined;
+    /** Whether all registered informers have reached a terminal state */
+    isFullySynced: boolean;
+    /** Sync progress as a 0-1 fraction (terminal states / total) */
+    syncProgress: number;
+    /** Number of informers that encountered errors */
+    errorCount: number;
+};
+export {};

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

@@ -0,0 +1,74 @@
+import { types } from '../../wailsjs/go/models';
+type UseResourceOptions = {
+    /**
+     * The ID of the plugin responsible for this resource
+     * @example "kubernetes"
+     */
+    pluginID?: string;
+    /**
+     * The connection ID to scope the resource to
+     * @example "integration"
+     */
+    connectionID: string;
+    /**
+     * The GVR (Group, Version, Resource) identifier to fetch
+     * @example "core::v1::pods"
+     */
+    resourceKey: string;
+    /**
+     * The ID of the resource to fetch
+     * @example "nginx-1452"
+     */
+    resourceID: string;
+    /**
+     * Optional namespace to scope the resource to, if the backend
+     * supports the concept of namespaces of resources.
+     * @example "default"
+     */
+    namespace?: string;
+    /**
+     * Optional parameters to pass to the resource fetch
+     * @example { labelSelector: "app=nginx" }
+     */
+    getParams?: Record<string, unknown>;
+    /**
+     * Optional parameters to pass to the resource update
+     * @example { dryRun: true }
+     */
+    updateParams?: Record<string, unknown>;
+    /**
+    * Optional parameters to pass to the resource delete
+    * @example { cascade: true }
+    * @example { force: true }
+    */
+    deleteParams?: Record<string, unknown>;
+};
+/**
+ * The useResource hook returns a hook, scoped to the desired resource and connection, that allows for interacting
+ * with, and fetching, the resource data.
+ *
+ * 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, getParams, updateParams, deleteParams, }: 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.
+     */
+    resource: import('@tanstack/react-query').UseQueryResult<types.GetResult, Error>;
+    /**
+     * Update an existing resource. A set of optional parameters can be passed to customize the update behavior,
+     * which if specified, will add additional default behavior set via the hook options.
+     *
+     * @params opts Optional parameters to pass to the resource update
+     */
+    update: import('@tanstack/react-query').UseMutateAsyncFunction<types.UpdateResult, unknown, Partial<types.UpdateInput>, unknown>;
+    /**
+     * Delete an existing resource. A set of optional parameters can be passed to customize the delete behavior,
+     * which if specified, will add additional default behavior set via the hook options.
+     *
+     * @params {object} opts Optional parameters to pass to the resource delete
+     */
+    remove: import('@tanstack/react-query').UseMutateAsyncFunction<types.DeleteResult, unknown, Partial<types.DeleteInput>, unknown>;
+};
+export default useResource;

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

@@ -0,0 +1,69 @@
+import { types } from '../../wailsjs/go/models';
+type UseResourceActionsOptions = {
+    /**
+     * The ID of the plugin responsible for this resource
+     * @example "kubernetes"
+     */
+    pluginID?: string;
+    /**
+     * The connection ID to scope the resource to
+     * @example "integration"
+     */
+    connectionID: string;
+    /**
+     * The resource type key
+     * @example "helm::v1::Release"
+     */
+    resourceKey: string;
+    /**
+     * Whether to enable the actions query
+     * @default true
+     */
+    enabled?: boolean;
+};
+/**
+ * useResourceActions discovers available actions for a resource type.
+ * Returns the list of ActionDescriptors that the backend reports for the given resource key.
+ */
+export declare const useResourceActions: ({ pluginID: explicitPluginID, connectionID, resourceKey, enabled, }: UseResourceActionsOptions) => {
+    actions: types.ActionDescriptor[];
+    isLoading: boolean;
+    error: Error | null;
+};
+type UseExecuteActionOptions = {
+    /**
+     * The ID of the plugin responsible for this resource
+     * @example "kubernetes"
+     */
+    pluginID?: string;
+    /**
+     * The connection ID to scope the resource to
+     * @example "integration"
+     */
+    connectionID: string;
+    /**
+     * The resource type key
+     * @example "helm::v1::Release"
+     */
+    resourceKey: string;
+};
+type ExecuteActionParams = {
+    /** The action ID to execute */
+    actionID: string;
+    /** The resource ID (for instance-scoped actions) */
+    id?: string;
+    /** The resource namespace */
+    namespace?: string;
+    /** Action-specific parameters */
+    params?: Record<string, unknown>;
+};
+/**
+ * useExecuteAction provides a mutation for executing a resource action.
+ * Returns a mutate function that can be called with action details.
+ */
+export declare const useExecuteAction: ({ pluginID: explicitPluginID, connectionID, resourceKey, }: UseExecuteActionOptions) => {
+    executeAction: import('@tanstack/react-query').UseMutateAsyncFunction<types.ActionResult, unknown, ExecuteActionParams, unknown>;
+    isExecuting: boolean;
+    error: unknown;
+};
+export default useResourceActions;

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

@@ -0,0 +1,9 @@
+import { ui } from '../../wailsjs/go/models';
+export declare const useResourceAreaComponent: (params: ui.GetResourceAreaComponentInput) => {
+    /**
+     * 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.
+     */
+    component: import('@tanstack/react-query').UseQueryResult<ui.ResourceComponent, Error>;
+};
+export default useResourceAreaComponent;