query-optimistic 0.3.4 → 0.4.1

package/dist/channel-OFFEKFI1.d.mts

@@ -0,0 +1,188 @@
+/**
+ * Core types for query-toolkit
+ * Framework-agnostic definitions
+ */
+/** Extract the ID from an entity */
+type IdGetter<T> = (item: T) => string;
+/** Optimistic status for pending mutations */
+type OptimisticStatus = 'pending' | 'success' | 'error';
+/** Wraps an entity with optimistic metadata */
+type Optimistic<T> = T & {
+    _optimistic?: {
+        id: string;
+        status: OptimisticStatus;
+        error?: string;
+    };
+};
+/** Collection definition for arrays of items */
+interface CollectionDef<TData, TParams = void> {
+    readonly _type: 'collection';
+    readonly name: string;
+    readonly id: IdGetter<TData>;
+    readonly fetch: (params: TParams) => Promise<TData[]>;
+}
+/** Entity definition for single items */
+interface EntityDef<TData, TParams = void> {
+    readonly _type: 'entity';
+    readonly name: string;
+    readonly fetch: (params: TParams) => Promise<TData>;
+}
+/** Mutation definition */
+interface MutationDef<TParams, TResponse = void> {
+    readonly _type: 'mutation';
+    readonly name?: string;
+    readonly mutate: (params: TParams) => Promise<TResponse>;
+}
+/** Unified definition type */
+type AnyDef = CollectionDef<any, any> | EntityDef<any, any>;
+/** Optimistic action types */
+type OptimisticAction = 'prepend' | 'append' | 'update' | 'delete' | 'replace';
+/** Optimistic update instruction */
+interface OptimisticInstruction<T = any> {
+    target: CollectionDef<T, any> | EntityDef<T, any>;
+    action: OptimisticAction;
+    data?: Partial<T>;
+    id?: string;
+    where?: (item: T) => boolean;
+    update?: (item: T) => T;
+}
+/** Options for query execution */
+interface QueryOptions {
+    enabled?: boolean;
+    staleTime?: number;
+    cacheTime?: number;
+    refetchOnMount?: boolean;
+    refetchOnWindowFocus?: boolean;
+    refetchInterval?: number | false;
+}
+/** Options for paginated queries */
+interface PaginatedOptions extends QueryOptions {
+    getNextPageParam?: (lastPage: any[], allPages: any[][]) => unknown | undefined;
+}
+
+/** Transaction returned from channel methods */
+interface OptimisticTransaction {
+    target: CollectionDef<any, any> | EntityDef<any, any>;
+    action: 'prepend' | 'append' | 'update' | 'delete' | 'replace';
+    data?: any;
+    id?: string;
+    where?: (item: any) => boolean;
+    update?: (item: any) => any;
+    sync?: boolean;
+    rollback: () => void;
+}
+/** Options for channel operations */
+interface ChannelOptions {
+    /**
+     * Only apply updates to queries whose params partially match this object.
+     * All key-value pairs in scope must exist in the query's params.
+     * @example
+     * channel(ordersCollection, { scope: { chain: 'solana' } }).delete(id)
+     * // Only affects queries with params containing chain: 'solana'
+     */
+    scope?: Record<string, unknown>;
+}
+/** Channel for a collection - provides typed optimistic mutation methods */
+declare class CollectionChannel<TEntity> {
+    private readonly target;
+    private readonly options?;
+    private readonly optimisticId;
+    constructor(target: CollectionDef<TEntity, any>, options?: ChannelOptions | undefined);
+    /**
+     * Prepend an item to the collection
+     * @returns Rollback function to undo the change
+     */
+    prepend(data: TEntity, options?: {
+        sync?: boolean;
+    }): () => void;
+    /**
+     * Append an item to the collection
+     * @returns Rollback function to undo the change
+     */
+    append(data: TEntity, options?: {
+        sync?: boolean;
+    }): () => void;
+    /**
+     * Update an item in the collection by ID
+     * @returns Rollback function to undo the change
+     */
+    update(id: string, updateFn: (item: TEntity) => TEntity, options?: {
+        sync?: boolean;
+    }): () => void;
+    /**
+     * Update items matching a predicate
+     * @returns Rollback function to undo the change
+     */
+    updateWhere(where: (item: TEntity) => boolean, updateFn: (item: TEntity) => TEntity): () => void;
+    /**
+     * Delete an item from the collection by ID
+     * @returns Rollback function to undo the change
+     */
+    delete(id: string): () => void;
+    /**
+     * Delete items matching a predicate
+     * @returns Rollback function to undo the change
+     */
+    deleteWhere(where: (item: TEntity) => boolean): () => void;
+}
+/** Channel for an entity - provides typed optimistic mutation methods */
+declare class EntityChannel<TEntity> {
+    private readonly target;
+    constructor(target: EntityDef<TEntity, any>);
+    /**
+     * Update the entity
+     * @returns Rollback function to undo the change
+     */
+    update(updateFn: (item: TEntity) => TEntity, options?: {
+        sync?: boolean;
+    }): () => void;
+    /**
+     * Replace the entity with new data
+     * @returns Rollback function to undo the change
+     */
+    replace(data: TEntity, options?: {
+        sync?: boolean;
+    }): () => void;
+}
+/**
+ * Channel function for optimistic mutations.
+ * Call with a collection or entity to get typed mutation methods.
+ *
+ * @example
+ * // Standalone usage
+ * const rollback = channel(usersCollection).prepend({ id: '1', name: 'John' });
+ * // Later, to undo:
+ * rollback();
+ *
+ * @example
+ * // Update an entity
+ * channel(userEntity).update(user => ({ ...user, name: 'Jane' }));
+ *
+ * @example
+ * // Scoped update
+ * channel(ordersCollection, { scope: { chain: 'solana' } }).delete(id);
+ * // Only affects queries with params containing chain: 'solana'
+ */
+interface Channel {
+    <TEntity>(target: CollectionDef<TEntity, any>, options?: ChannelOptions): CollectionChannel<TEntity>;
+    <TEntity>(target: EntityDef<TEntity, any>): EntityChannel<TEntity>;
+}
+/**
+ * Create a channel for optimistic mutations.
+ * Use this to apply immediate UI updates that can be rolled back.
+ *
+ * @example
+ * const rollback = channel(usersCollection).prepend(newUser);
+ * try {
+ *   await api.createUser(newUser);
+ * } catch (error) {
+ *   rollback(); // Undo the optimistic update
+ * }
+ *
+ * @example
+ * // Scoped update - only affects queries with matching params
+ * channel(ordersCollection, { scope: { chain: 'solana', status: 'pending' } }).delete(id);
+ */
+declare const channel: Channel;
+
+export { type AnyDef as A, type Channel as C, EntityChannel as E, type IdGetter as I, type MutationDef as M, type Optimistic as O, type PaginatedOptions as P, type QueryOptions as Q, type ChannelOptions as a, CollectionChannel as b, type CollectionDef as c, type EntityDef as d, type OptimisticAction as e, type OptimisticInstruction as f, type OptimisticStatus as g, type OptimisticTransaction as h, channel as i };

package/dist/channel-OFFEKFI1.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Core types for query-toolkit
+ * Framework-agnostic definitions
+ */
+/** Extract the ID from an entity */
+type IdGetter<T> = (item: T) => string;
+/** Optimistic status for pending mutations */
+type OptimisticStatus = 'pending' | 'success' | 'error';
+/** Wraps an entity with optimistic metadata */
+type Optimistic<T> = T & {
+    _optimistic?: {
+        id: string;
+        status: OptimisticStatus;
+        error?: string;
+    };
+};
+/** Collection definition for arrays of items */
+interface CollectionDef<TData, TParams = void> {
+    readonly _type: 'collection';
+    readonly name: string;
+    readonly id: IdGetter<TData>;
+    readonly fetch: (params: TParams) => Promise<TData[]>;
+}
+/** Entity definition for single items */
+interface EntityDef<TData, TParams = void> {
+    readonly _type: 'entity';
+    readonly name: string;
+    readonly fetch: (params: TParams) => Promise<TData>;
+}
+/** Mutation definition */
+interface MutationDef<TParams, TResponse = void> {
+    readonly _type: 'mutation';
+    readonly name?: string;
+    readonly mutate: (params: TParams) => Promise<TResponse>;
+}
+/** Unified definition type */
+type AnyDef = CollectionDef<any, any> | EntityDef<any, any>;
+/** Optimistic action types */
+type OptimisticAction = 'prepend' | 'append' | 'update' | 'delete' | 'replace';
+/** Optimistic update instruction */
+interface OptimisticInstruction<T = any> {
+    target: CollectionDef<T, any> | EntityDef<T, any>;
+    action: OptimisticAction;
+    data?: Partial<T>;
+    id?: string;
+    where?: (item: T) => boolean;
+    update?: (item: T) => T;
+}
+/** Options for query execution */
+interface QueryOptions {
+    enabled?: boolean;
+    staleTime?: number;
+    cacheTime?: number;
+    refetchOnMount?: boolean;
+    refetchOnWindowFocus?: boolean;
+    refetchInterval?: number | false;
+}
+/** Options for paginated queries */
+interface PaginatedOptions extends QueryOptions {
+    getNextPageParam?: (lastPage: any[], allPages: any[][]) => unknown | undefined;
+}
+
+/** Transaction returned from channel methods */
+interface OptimisticTransaction {
+    target: CollectionDef<any, any> | EntityDef<any, any>;
+    action: 'prepend' | 'append' | 'update' | 'delete' | 'replace';
+    data?: any;
+    id?: string;
+    where?: (item: any) => boolean;
+    update?: (item: any) => any;
+    sync?: boolean;
+    rollback: () => void;
+}
+/** Options for channel operations */
+interface ChannelOptions {
+    /**
+     * Only apply updates to queries whose params partially match this object.
+     * All key-value pairs in scope must exist in the query's params.
+     * @example
+     * channel(ordersCollection, { scope: { chain: 'solana' } }).delete(id)
+     * // Only affects queries with params containing chain: 'solana'
+     */
+    scope?: Record<string, unknown>;
+}
+/** Channel for a collection - provides typed optimistic mutation methods */
+declare class CollectionChannel<TEntity> {
+    private readonly target;
+    private readonly options?;
+    private readonly optimisticId;
+    constructor(target: CollectionDef<TEntity, any>, options?: ChannelOptions | undefined);
+    /**
+     * Prepend an item to the collection
+     * @returns Rollback function to undo the change
+     */
+    prepend(data: TEntity, options?: {
+        sync?: boolean;
+    }): () => void;
+    /**
+     * Append an item to the collection
+     * @returns Rollback function to undo the change
+     */
+    append(data: TEntity, options?: {
+        sync?: boolean;
+    }): () => void;
+    /**
+     * Update an item in the collection by ID
+     * @returns Rollback function to undo the change
+     */
+    update(id: string, updateFn: (item: TEntity) => TEntity, options?: {
+        sync?: boolean;
+    }): () => void;
+    /**
+     * Update items matching a predicate
+     * @returns Rollback function to undo the change
+     */
+    updateWhere(where: (item: TEntity) => boolean, updateFn: (item: TEntity) => TEntity): () => void;
+    /**
+     * Delete an item from the collection by ID
+     * @returns Rollback function to undo the change
+     */
+    delete(id: string): () => void;
+    /**
+     * Delete items matching a predicate
+     * @returns Rollback function to undo the change
+     */
+    deleteWhere(where: (item: TEntity) => boolean): () => void;
+}
+/** Channel for an entity - provides typed optimistic mutation methods */
+declare class EntityChannel<TEntity> {
+    private readonly target;
+    constructor(target: EntityDef<TEntity, any>);
+    /**
+     * Update the entity
+     * @returns Rollback function to undo the change
+     */
+    update(updateFn: (item: TEntity) => TEntity, options?: {
+        sync?: boolean;
+    }): () => void;
+    /**
+     * Replace the entity with new data
+     * @returns Rollback function to undo the change
+     */
+    replace(data: TEntity, options?: {
+        sync?: boolean;
+    }): () => void;
+}
+/**
+ * Channel function for optimistic mutations.
+ * Call with a collection or entity to get typed mutation methods.
+ *
+ * @example
+ * // Standalone usage
+ * const rollback = channel(usersCollection).prepend({ id: '1', name: 'John' });
+ * // Later, to undo:
+ * rollback();
+ *
+ * @example
+ * // Update an entity
+ * channel(userEntity).update(user => ({ ...user, name: 'Jane' }));
+ *
+ * @example
+ * // Scoped update
+ * channel(ordersCollection, { scope: { chain: 'solana' } }).delete(id);
+ * // Only affects queries with params containing chain: 'solana'
+ */
+interface Channel {
+    <TEntity>(target: CollectionDef<TEntity, any>, options?: ChannelOptions): CollectionChannel<TEntity>;
+    <TEntity>(target: EntityDef<TEntity, any>): EntityChannel<TEntity>;
+}
+/**
+ * Create a channel for optimistic mutations.
+ * Use this to apply immediate UI updates that can be rolled back.
+ *
+ * @example
+ * const rollback = channel(usersCollection).prepend(newUser);
+ * try {
+ *   await api.createUser(newUser);
+ * } catch (error) {
+ *   rollback(); // Undo the optimistic update
+ * }
+ *
+ * @example
+ * // Scoped update - only affects queries with matching params
+ * channel(ordersCollection, { scope: { chain: 'solana', status: 'pending' } }).delete(id);
+ */
+declare const channel: Channel;
+
+export { type AnyDef as A, type Channel as C, EntityChannel as E, type IdGetter as I, type MutationDef as M, type Optimistic as O, type PaginatedOptions as P, type QueryOptions as Q, type ChannelOptions as a, CollectionChannel as b, type CollectionDef as c, type EntityDef as d, type OptimisticAction as e, type OptimisticInstruction as f, type OptimisticStatus as g, type OptimisticTransaction as h, channel as i };

package/dist/core/index.d.mts

@@ -1,5 +1,6 @@
-import { I as IdGetter, C as CollectionDef, E as EntityDef, M as MutationDef, O as Optimistic } from '../types-BOq5W_Qm.mjs';
-export { A as AnyDef, a as OptimisticAction, b as OptimisticInstruction, c as OptimisticStatus, P as PaginatedOptions, Q as QueryOptions } from '../types-BOq5W_Qm.mjs';
+import { I as IdGetter, c as CollectionDef, d as EntityDef, M as MutationDef, O as Optimistic } from '../channel-OFFEKFI1.mjs';
+export { A as AnyDef, C as Channel, a as ChannelOptions, b as CollectionChannel, E as EntityChannel, e as OptimisticAction, f as OptimisticInstruction, g as OptimisticStatus, h as OptimisticTransaction, P as PaginatedOptions, Q as QueryOptions, i as channel } from '../channel-OFFEKFI1.mjs';
+import { QueryClient } from '@tanstack/react-query';
 
 /**
  * Define a collection query for fetching arrays of items
@@ -86,126 +87,35 @@ type RegisteredEntry = RegisteredCollection | RegisteredEntity | RegisteredPagin
  */
 declare class QueryRegistry {
     private entries;
+    private queryClient;
+    private collectionDefs;
+    /** Set the query client for direct cache access */
+    setQueryClient(client: QueryClient): void;
+    /** Register a collection definition for direct cache updates */
+    registerDef(def: CollectionDef<any, any>): void;
     /** Register an active query */
     register(entry: RegisteredEntry): void;
     /** Unregister a query when component unmounts */
     unregister(entry: RegisteredEntry): void;
     /** Get all registered entries for a query name */
     getByName(name: string): RegisteredEntry[];
+    /**
+     * Check if params partially match the given scope object.
+     * Returns true if all key-value pairs in scope exist in params.
+     */
+    private matchesScope;
     /** Apply an optimistic update to all queries with given name */
     applyUpdate<T>(name: string, action: 'prepend' | 'append' | 'update' | 'delete' | 'replace', payload: {
         data?: Partial<Optimistic<T>>;
         id?: string;
         where?: (item: T) => boolean;
         update?: (item: T) => T;
-    }): (() => void)[];
+    }, scope?: Record<string, unknown>): (() => void)[];
+    /** Apply update directly to query cache (used when scope is provided) */
+    private applyDirectCacheUpdate;
     private applyCollectionUpdate;
 }
 /** Singleton registry instance */
 declare const registry: QueryRegistry;
 
-/** Transaction returned from channel methods */
-interface OptimisticTransaction {
-    target: CollectionDef<any, any> | EntityDef<any, any>;
-    action: 'prepend' | 'append' | 'update' | 'delete' | 'replace';
-    data?: any;
-    id?: string;
-    where?: (item: any) => boolean;
-    update?: (item: any) => any;
-    sync?: boolean;
-    rollback: () => void;
-}
-/** Channel for a collection - provides typed optimistic mutation methods */
-declare class CollectionChannel<TEntity> {
-    private readonly target;
-    private readonly optimisticId;
-    constructor(target: CollectionDef<TEntity, any>);
-    /**
-     * Prepend an item to the collection
-     * @returns Rollback function to undo the change
-     */
-    prepend(data: TEntity, options?: {
-        sync?: boolean;
-    }): () => void;
-    /**
-     * Append an item to the collection
-     * @returns Rollback function to undo the change
-     */
-    append(data: TEntity, options?: {
-        sync?: boolean;
-    }): () => void;
-    /**
-     * Update an item in the collection by ID
-     * @returns Rollback function to undo the change
-     */
-    update(id: string, updateFn: (item: TEntity) => TEntity, options?: {
-        sync?: boolean;
-    }): () => void;
-    /**
-     * Update items matching a predicate
-     * @returns Rollback function to undo the change
-     */
-    updateWhere(where: (item: TEntity) => boolean, updateFn: (item: TEntity) => TEntity): () => void;
-    /**
-     * Delete an item from the collection by ID
-     * @returns Rollback function to undo the change
-     */
-    delete(id: string): () => void;
-    /**
-     * Delete items matching a predicate
-     * @returns Rollback function to undo the change
-     */
-    deleteWhere(where: (item: TEntity) => boolean): () => void;
-}
-/** Channel for an entity - provides typed optimistic mutation methods */
-declare class EntityChannel<TEntity> {
-    private readonly target;
-    constructor(target: EntityDef<TEntity, any>);
-    /**
-     * Update the entity
-     * @returns Rollback function to undo the change
-     */
-    update(updateFn: (item: TEntity) => TEntity, options?: {
-        sync?: boolean;
-    }): () => void;
-    /**
-     * Replace the entity with new data
-     * @returns Rollback function to undo the change
-     */
-    replace(data: TEntity, options?: {
-        sync?: boolean;
-    }): () => void;
-}
-/**
- * Channel function for optimistic mutations.
- * Call with a collection or entity to get typed mutation methods.
- *
- * @example
- * // Standalone usage
- * const rollback = channel(usersCollection).prepend({ id: '1', name: 'John' });
- * // Later, to undo:
- * rollback();
- *
- * @example
- * // Update an entity
- * channel(userEntity).update(user => ({ ...user, name: 'Jane' }));
- */
-interface Channel {
-    <TEntity>(target: CollectionDef<TEntity, any>): CollectionChannel<TEntity>;
-    <TEntity>(target: EntityDef<TEntity, any>): EntityChannel<TEntity>;
-}
-/**
- * Create a channel for optimistic mutations.
- * Use this to apply immediate UI updates that can be rolled back.
- *
- * @example
- * const rollback = channel(usersCollection).prepend(newUser);
- * try {
- *   await api.createUser(newUser);
- * } catch (error) {
- *   rollback(); // Undo the optimistic update
- * }
- */
-declare const channel: Channel;
-
-export { type Channel, CollectionChannel, CollectionDef, EntityChannel, EntityDef, IdGetter, MutationDef, Optimistic, type OptimisticTransaction, type RegisteredCollection, type RegisteredEntity, type RegisteredEntry, type RegisteredPaginatedCollection, channel, defineCollection, defineEntity, defineMutation, registry };
+export { CollectionDef, EntityDef, IdGetter, MutationDef, Optimistic, type RegisteredCollection, type RegisteredEntity, type RegisteredEntry, type RegisteredPaginatedCollection, defineCollection, defineEntity, defineMutation, registry };

package/dist/core/index.d.ts

@@ -1,5 +1,6 @@
-import { I as IdGetter, C as CollectionDef, E as EntityDef, M as MutationDef, O as Optimistic } from '../types-BOq5W_Qm.js';
-export { A as AnyDef, a as OptimisticAction, b as OptimisticInstruction, c as OptimisticStatus, P as PaginatedOptions, Q as QueryOptions } from '../types-BOq5W_Qm.js';
+import { I as IdGetter, c as CollectionDef, d as EntityDef, M as MutationDef, O as Optimistic } from '../channel-OFFEKFI1.js';
+export { A as AnyDef, C as Channel, a as ChannelOptions, b as CollectionChannel, E as EntityChannel, e as OptimisticAction, f as OptimisticInstruction, g as OptimisticStatus, h as OptimisticTransaction, P as PaginatedOptions, Q as QueryOptions, i as channel } from '../channel-OFFEKFI1.js';
+import { QueryClient } from '@tanstack/react-query';
 
 /**
  * Define a collection query for fetching arrays of items
@@ -86,126 +87,35 @@ type RegisteredEntry = RegisteredCollection | RegisteredEntity | RegisteredPagin
  */
 declare class QueryRegistry {
     private entries;
+    private queryClient;
+    private collectionDefs;
+    /** Set the query client for direct cache access */
+    setQueryClient(client: QueryClient): void;
+    /** Register a collection definition for direct cache updates */
+    registerDef(def: CollectionDef<any, any>): void;
     /** Register an active query */
     register(entry: RegisteredEntry): void;
     /** Unregister a query when component unmounts */
     unregister(entry: RegisteredEntry): void;
     /** Get all registered entries for a query name */
     getByName(name: string): RegisteredEntry[];
+    /**
+     * Check if params partially match the given scope object.
+     * Returns true if all key-value pairs in scope exist in params.
+     */
+    private matchesScope;
     /** Apply an optimistic update to all queries with given name */
     applyUpdate<T>(name: string, action: 'prepend' | 'append' | 'update' | 'delete' | 'replace', payload: {
         data?: Partial<Optimistic<T>>;
         id?: string;
         where?: (item: T) => boolean;
         update?: (item: T) => T;
-    }): (() => void)[];
+    }, scope?: Record<string, unknown>): (() => void)[];
+    /** Apply update directly to query cache (used when scope is provided) */
+    private applyDirectCacheUpdate;
     private applyCollectionUpdate;
 }
 /** Singleton registry instance */
 declare const registry: QueryRegistry;
 
-/** Transaction returned from channel methods */
-interface OptimisticTransaction {
-    target: CollectionDef<any, any> | EntityDef<any, any>;
-    action: 'prepend' | 'append' | 'update' | 'delete' | 'replace';
-    data?: any;
-    id?: string;
-    where?: (item: any) => boolean;
-    update?: (item: any) => any;
-    sync?: boolean;
-    rollback: () => void;
-}
-/** Channel for a collection - provides typed optimistic mutation methods */
-declare class CollectionChannel<TEntity> {
-    private readonly target;
-    private readonly optimisticId;
-    constructor(target: CollectionDef<TEntity, any>);
-    /**
-     * Prepend an item to the collection
-     * @returns Rollback function to undo the change
-     */
-    prepend(data: TEntity, options?: {
-        sync?: boolean;
-    }): () => void;
-    /**
-     * Append an item to the collection
-     * @returns Rollback function to undo the change
-     */
-    append(data: TEntity, options?: {
-        sync?: boolean;
-    }): () => void;
-    /**
-     * Update an item in the collection by ID
-     * @returns Rollback function to undo the change
-     */
-    update(id: string, updateFn: (item: TEntity) => TEntity, options?: {
-        sync?: boolean;
-    }): () => void;
-    /**
-     * Update items matching a predicate
-     * @returns Rollback function to undo the change
-     */
-    updateWhere(where: (item: TEntity) => boolean, updateFn: (item: TEntity) => TEntity): () => void;
-    /**
-     * Delete an item from the collection by ID
-     * @returns Rollback function to undo the change
-     */
-    delete(id: string): () => void;
-    /**
-     * Delete items matching a predicate
-     * @returns Rollback function to undo the change
-     */
-    deleteWhere(where: (item: TEntity) => boolean): () => void;
-}
-/** Channel for an entity - provides typed optimistic mutation methods */
-declare class EntityChannel<TEntity> {
-    private readonly target;
-    constructor(target: EntityDef<TEntity, any>);
-    /**
-     * Update the entity
-     * @returns Rollback function to undo the change
-     */
-    update(updateFn: (item: TEntity) => TEntity, options?: {
-        sync?: boolean;
-    }): () => void;
-    /**
-     * Replace the entity with new data
-     * @returns Rollback function to undo the change
-     */
-    replace(data: TEntity, options?: {
-        sync?: boolean;
-    }): () => void;
-}
-/**
- * Channel function for optimistic mutations.
- * Call with a collection or entity to get typed mutation methods.
- *
- * @example
- * // Standalone usage
- * const rollback = channel(usersCollection).prepend({ id: '1', name: 'John' });
- * // Later, to undo:
- * rollback();
- *
- * @example
- * // Update an entity
- * channel(userEntity).update(user => ({ ...user, name: 'Jane' }));
- */
-interface Channel {
-    <TEntity>(target: CollectionDef<TEntity, any>): CollectionChannel<TEntity>;
-    <TEntity>(target: EntityDef<TEntity, any>): EntityChannel<TEntity>;
-}
-/**
- * Create a channel for optimistic mutations.
- * Use this to apply immediate UI updates that can be rolled back.
- *
- * @example
- * const rollback = channel(usersCollection).prepend(newUser);
- * try {
- *   await api.createUser(newUser);
- * } catch (error) {
- *   rollback(); // Undo the optimistic update
- * }
- */
-declare const channel: Channel;
-
-export { type Channel, CollectionChannel, CollectionDef, EntityChannel, EntityDef, IdGetter, MutationDef, Optimistic, type OptimisticTransaction, type RegisteredCollection, type RegisteredEntity, type RegisteredEntry, type RegisteredPaginatedCollection, channel, defineCollection, defineEntity, defineMutation, registry };
+export { CollectionDef, EntityDef, IdGetter, MutationDef, Optimistic, type RegisteredCollection, type RegisteredEntity, type RegisteredEntry, type RegisteredPaginatedCollection, defineCollection, defineEntity, defineMutation, registry };