@omniviewdev/runtime 0.10.0 → 0.11.0

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

@@ -0,0 +1,162 @@
+import { ResolveTargetRequest } from '../../resource/v2/host';
+/** Authority, generation and representation admission belong to the host. */
+export declare function useResolvedResourceTarget({ pluginID: explicitPluginID, enabled, ...request }: ResolveTargetRequest & {
+    pluginID?: string;
+    enabled?: boolean;
+}): {
+    data: import('../..').ResolvedResourceTarget | undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('../..').ResolvedResourceTarget, Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+} | {
+    data: import('../..').ResolvedResourceTarget | undefined;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('../..').ResolvedResourceTarget, Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+} | {
+    data: import('../..').ResolvedResourceTarget | undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('../..').ResolvedResourceTarget, Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+} | {
+    data: import('../..').ResolvedResourceTarget | undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('../..').ResolvedResourceTarget, Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+} | {
+    data: import('../..').ResolvedResourceTarget | undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('../..').ResolvedResourceTarget, Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+} | {
+    data: import('../..').ResolvedResourceTarget | undefined;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('../..').ResolvedResourceTarget, Error>>;
+    fetchStatus: import('@tanstack/react-query').FetchStatus;
+};

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

@@ -1,62 +1,11 @@
-type UseResourceOptions = {
-    /**
-     * The ID of the plugin responsible for this resource
-     * @example "kubernetes"
-     */
+import { MutationRequest } from '../../resource/v2/domain';
+import { HostGetRequest } from '../../resource/v2/host';
+export declare const useResource: ({ pluginID: explicitPluginID, request, enabled, }: {
     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;
+    request?: HostGetRequest;
     enabled?: boolean;
-};
-/**
- * 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, 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.
-     */
-    resource: import('@tanstack/react-query').UseQueryResult<import('../../models').GetResult | null, 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<import('../../models').UpdateResult | null, unknown, {
-        input?: unknown;
-    }, 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<import('../../models').DeleteResult | null, unknown, {
-        gracePeriodSeconds?: number;
-    }, unknown>;
+}) => {
+    resource: import('@tanstack/react-query').UseQueryResult<import('../..').HostRecord, Error>;
+    mutate: import('@tanstack/react-query').UseMutateAsyncFunction<import('../..').Record, unknown, Omit<MutationRequest, "route" | "reference">, unknown>;
 };
 export default useResource;

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

@@ -1,67 +1,18 @@
-type UseResourceActionsOptions = {
-    /**
-     * The ID of the plugin responsible for this resource
-     * @example "kubernetes"
-     */
+import { AccessRoute, ActionRequest } from '../../resource/v2/domain';
+export declare const useResourceActions: ({ pluginID: explicitPluginID, route, type, enabled, }: {
     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
-     */
+    route: AccessRoute;
+    type: string;
     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: import('../../models').ActionDescriptor[];
+}) => {
+    actions: import('../..').ActionDescriptor[];
     isLoading: boolean;
     error: Error | null;
 };
-type UseExecuteActionOptions = {
-    /**
-     * The ID of the plugin responsible for this resource
-     * @example "kubernetes"
-     */
+export declare const useExecuteAction: ({ pluginID: explicitPluginID }: {
     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<import('../../models').ActionResult | null, unknown, ExecuteActionParams, unknown>;
+}) => {
+    executeAction: import('@tanstack/react-query').UseMutateAsyncFunction<import('../..').Value, unknown, ActionRequest, unknown>;
     isExecuting: boolean;
     error: unknown;
 };

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

@@ -1,20 +1,12 @@
+import { AccessRoute, ResourceReference } from '../../resource/v2/domain';
 type UseResourceGraphOptions = {
     /**
      * The ID of the plugin responsible for this resource
      * @example "kubernetes"
      */
     pluginID?: string;
-    /** The connection ID the resource belongs to */
-    connectionID: string;
-    /**
-     * The resource key of the root resource
-     * @example "core::v1::Pod"
-     */
-    resourceKey: string;
-    /** The ID of the root resource */
-    resourceID: string;
-    /** Namespace of the root resource, if the backend has namespaces */
-    namespace?: string;
+    reference: ResourceReference;
+    route: AccessRoute;
     /**
      * How many hops to follow against edge direction: owners, selectors and
      * other resources pointing at the root. The host caps this at 5.
@@ -36,7 +28,7 @@ type UseResourceGraphOptions = {
  * paths keeps all of its edges. Refetches when the host reports a graph
  * change for the connection.
  */
-export declare const useResourceGraph: ({ pluginID: explicitPluginID, connectionID, resourceKey, resourceID, namespace, upDepth, downDepth, enabled, }: UseResourceGraphOptions) => {
+export declare const useResourceGraph: ({ pluginID: explicitPluginID, reference, route, upDepth, downDepth, enabled, }: UseResourceGraphOptions) => {
     graph: import('../../models').Subgraph | null;
     isLoading: boolean;
     isFetching: boolean;

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

@@ -1,23 +1,9 @@
-type UseResourceGroupsOptions = {
-    /**
-     * The ID of the plugin
-     */
+import { AccessRoute } from '../../resource/v2/domain';
+export declare const useResourceGroups: ({ pluginID: explicitPluginID, route, enabled }: {
     pluginID?: string;
-    /**
-     * The ID of the connection
-     */
-    connectionID: string;
+    route: AccessRoute;
     enabled?: boolean;
-};
-/**
- * Fetch the resource groups for a given plugin and connection.
- */
-export declare const useResourceGroups: ({ pluginID: explicitPluginID, connectionID, enabled }: UseResourceGroupsOptions) => {
-    /**
-     * The resource groups for the given plugin and connection.
-     */
-    groups: import('@tanstack/react-query').UseQueryResult<{
-        [x: string]: import('../../models').ResourceGroup | undefined;
-    }, Error>;
+}) => {
+    groups: import('@tanstack/react-query').UseQueryResult<import('../..').ResourceGroup[], Error>;
 };
 export default useResourceGroups;

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

@@ -1,64 +1,8 @@
-type ResourceMutationOptions = {
-    /**
-     * 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 call
-     * @example { labelSelector: "app=nginx" }
-     */
-    params?: Record<string, unknown>;
-};
-type UseResourceMutationsOptions = {
-    /**
-     * The ID of the plugin responsible for this resource
-     * @example "kubernetes"
-     */
+import { MutationRequest } from '../../resource/v2/domain';
+export declare const useResourceMutations: ({ pluginID: explicitPluginID }: {
     pluginID?: string;
-};
-/**
- * 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 useResourceMutations: ({ pluginID: explicitPluginID }: UseResourceMutationsOptions) => {
-    create: import('@tanstack/react-query').UseMutateAsyncFunction<import('../../models').CreateResult | null, unknown, {
-        opts: ResourceMutationOptions;
-        input: {
-            input?: unknown;
-            namespace?: string;
-        };
-    }, unknown>;
-    update: import('@tanstack/react-query').UseMutateAsyncFunction<import('../../models').UpdateResult | null, unknown, {
-        opts: ResourceMutationOptions;
-        input: {
-            input?: unknown;
-        };
-    }, unknown>;
-    remove: import('@tanstack/react-query').UseMutateAsyncFunction<import('../../models').DeleteResult | null, unknown, {
-        opts: ResourceMutationOptions;
-        input: {
-            gracePeriodSeconds?: number;
-        };
-    }, unknown>;
+}) => {
+    mutate: import('@tanstack/react-query').UseMutateAsyncFunction<import('../..').Record, unknown, MutationRequest, unknown>;
+    mutation: import('@tanstack/react-query').UseMutationResult<import('../..').Record, unknown, MutationRequest, unknown>;
 };
 export default useResourceMutations;

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

@@ -1,37 +1,8 @@
-type UseResourceSearchOptions = {
-    /**
-     * The ID of the plugin responsible for this resource
-     * @example "kubernetes"
-     */
+import { HostNativeQueryRequest } from '../../resource/v2/host';
+/** Bounded provider-native acquisitions, not a host-wide query result. */
+export declare const useResourceSearch: ({ pluginID: explicitPluginID, searches, enabled, }: {
     pluginID?: string;
-    /**
-     * The connection ID to scope the resource to
-     * @example "integration"
-     */
-    connectionID: string;
-    /**
-     * Entry for the resource search
-     */
-    searches: ResourceSearchEntry[];
+    searches: readonly HostNativeQueryRequest[];
     enabled?: boolean;
-};
-type ResourceSearchEntry = {
-    /**
-    * The key of the resource
-    */
-    key: string;
-    /**
-     * The namespaces to search for the resource
-     */
-    namespaces: string[];
-    /**
-     * Post-retrieve function filter to apply after the resources are found
-     */
-    postFilter?: (resource: unknown) => boolean;
-};
-/**
- * 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, enabled, }: UseResourceSearchOptions) => import('@tanstack/react-query').UseQueryResult<any[], Error>[];
+}) => import('@tanstack/react-query').UseQueryResult<import('../..').HostSourcePage, Error>[];
 export default useResourceSearch;

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

@@ -1,22 +1,9 @@
-type UseResourceTypesOptions = {
-    /**
-     * The ID of the category responsible for this resource
-     * @example "appearance"
-     */
+import { AccessRoute } from '../../resource/v2/domain';
+export declare const useResourceType: ({ pluginID: explicitPluginID, route, type }: {
     pluginID?: string;
-    /**
-    * The key of the resource to fetch
-    */
-    resourceKey: string;
-};
-/**
- * Interact with a category of settings from the global settings provider. Intended for use in the settings UI - if
- * you need to read or write settings from a specific plugin, use the `@hooks/settings/useSettings` hook instead.
- */
-export declare const useResourceType: ({ pluginID: explicitPluginID, resourceKey }: UseResourceTypesOptions) => {
-    /**
-     * The current settings from the provider.
-     */
-    resourceType: import('@tanstack/react-query').UseQueryResult<import('../../models').ResourceMeta | null, Error>;
+    route: AccessRoute;
+    type: string;
+}) => {
+    resourceType: import('@tanstack/react-query').UseQueryResult<import('../..').ResourceType | undefined, Error>;
 };
 export default useResourceType;

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

@@ -1,23 +1,8 @@
-type UseResourceTypesOptions = {
-    /**
-     * The ID of the plugin
-     */
+import { AccessRoute } from '../../resource/v2/domain';
+export declare const useResourceTypes: ({ pluginID: explicitPluginID, route, enabled }: {
     pluginID?: string;
-    /**
-    * The ID of the connection
-    */
-    connectionID: string;
+    route: AccessRoute;
     enabled?: boolean;
+}) => {
+    resourceTypes: import('@tanstack/react-query').UseQueryResult<readonly import('../..').ResourceType[], Error>;
 };
-/**
- * Fetch the resource types for a given plugin and connection.
- */
-export declare const useResourceTypes: ({ pluginID: explicitPluginID, connectionID, enabled }: UseResourceTypesOptions) => {
-    /**
-     * The resource types for the given plugin and connection.
-     */
-    types: import('@tanstack/react-query').UseQueryResult<{
-        [x: string]: import('../../models').ResourceMeta | undefined;
-    }, Error>;
-};
-export {};

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

@@ -1,65 +1,37 @@
-type UseResourcesOptions = {
-    /**
-     * The ID of the plugin responsible for this resource
-     * @example "kubernetes"
-     */
+import { HostEnumerateRequest, ResourceView } from '../../resource/v2/host';
+import { WatchState } from '../../types/watch';
+export interface UseResourcesOptions {
     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;
-    /**
-     * Optional namespace to scope the resource to, if the backend
-     * supports the concept of namespaces of resources. If the backend
-     * supports the concept of namespaces, and this is not provided,
-     * it will default to selecting from all namespaces.
-     * @example "default"
-     */
-    namespaces?: string[];
-    /**
-     * The dot-delimited path on which id's can be used for updates. In order for the watch
-     * live functionality to work, this must be set to the path on which the ID is located.
-     */
-    idAccessor?: string;
+    request?: HostEnumerateRequest;
     enabled?: boolean;
-};
-/**
- * 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 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
-     * the per-resource hook mutation functions.
-     */
-    resources: import('@tanstack/react-query').UseQueryResult<import('../../models').ListResult | null, Error>;
-    /**
-     * Create a new resource. A set of optional parameters can be passed to customize the create behavior,
-     * which if specified, will add additional default behavior set via the hook options.
-     *
-     * @params opts Optional parameters to pass to the resource create operation
-     */
-    create: import('@tanstack/react-query').UseMutateAsyncFunction<import('../../models').CreateResult | null, unknown, {
-        input?: unknown;
-        namespace?: string;
-    }, unknown>;
-    /** Current watch state for this resource type */
-    watchState: import('../../bindings/github.com/omniviewdev/plugin-sdk/pkg/v1/resource').WatchState;
-    /** Whether the watch is currently syncing */
+    /** Actual advisory native updates, never inferred from a finite page. */
+    live?: boolean;
+}
+export interface AcquiredResourcePage {
+    /** Exact successful request, including its actual source cursor. */
+    request: HostEnumerateRequest;
+    page: ResourceView;
+}
+/** One attempted acquisition and one displayed successful page; never accumulated row history. */
+export declare const useResources: ({ pluginID: explicitPluginID, request, enabled, live }: UseResourcesOptions) => {
+    /** Attempted request state; an error does not rename or replace the acquired page. */
+    resources: import('@tanstack/react-query').UseQueryResult<import('../..').HostSourcePage, Error>;
+    acquired: AcquiredResourcePage | undefined;
+    /** Gate acquired readiness when a consumer chooses to display the attempted page instead. */
+    isAcquiredRequestCurrent: boolean;
+    refreshAcquiredPage: (options?: import('@tanstack/react-query').RefetchOptions) => Promise<import('@tanstack/react-query').QueryObserverResult<import('../..').HostSourcePage, Error>>;
+    view: {
+        guarantee: "bestEffort";
+        count: import('../..').Count;
+        sourceRevision?: string;
+        membershipStale: boolean;
+    } | undefined;
+    membershipStale: boolean;
+    watchState: WatchState;
+    isLive: boolean;
     isSyncing: boolean;
-    /** Whether the watch has fully synced */
+    /** Native cache readiness only, not snapshot/update continuity. */
     isSynced: boolean;
-    /** Whether the watch encountered an error */
-    watchError: boolean;
+    watchError: {} | undefined;
+    guarantee: "bestEffort" | undefined;
 };
-export {};

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

@@ -1,18 +1,14 @@
+import { ActionRequest } from '../../resource/v2/domain';
 type UseStreamActionOptions = {
     pluginID?: string;
-    connectionID: string;
-    resourceKey: string;
 };
 type StartStreamActionParams = {
-    actionID: string;
-    id: string;
-    namespace: string;
+    request: ActionRequest;
     label: string;
-    params?: Record<string, unknown>;
 };
 /** Host-ready open, listener-first attachment and owning cleanup of current actions. */
-export declare const useStreamAction: ({ pluginID: explicitPluginID, connectionID, resourceKey }: UseStreamActionOptions) => {
-    startStreamAction: ({ actionID, id, namespace, label, params }: StartStreamActionParams) => Promise<string>;
+export declare const useStreamAction: ({ pluginID: explicitPluginID }: UseStreamActionOptions) => {
+    startStreamAction: ({ request, label }: StartStreamActionParams) => Promise<string>;
     cancelStreamAction: (handle: string) => void;
 };
 export {};