@fozy-labs/rx-toolkit 0.5.3-rc.1 → 0.5.3

package/dist/query/api/createCommand.js

@@ -0,0 +1,20 @@
+import { Command } from "../../query/core/Command/Command";
+/**
+ * Создаёт команду (command) — единицу мутирующего запроса.
+ *
+ * Команда инкапсулирует асинхронную операцию с поддержкой кеширования,
+ * связывания с ресурсами (link) и оптимистичных обновлений.
+ *
+ * @example
+ * ```ts
+ * const updateUser = createCommand({
+ *   queryFn: (args: { id: string; name: string }) => api.updateUser(args),
+ *   link: (link) => link({
+ *     resource: userResource,
+ *     forwardArgs: (args) => ({ id: args.id }),
+ *     invalidate: true,
+ *   }),
+ * });
+ * ```
+ */
+export const createCommand = ((options) => new Command(options));

package/dist/query/api/createOperation.d.ts

@@ -1,3 +1,5 @@
-import type { OperationCreateOptions, OperationDefinition } from "@/query/types";
-import { Operation } from "@/query/core/Opertation/Operation";
-export declare const createOperation: <ARGS, RESULT, SELECTED = never>(options: OperationCreateOptions<OperationDefinition<ARGS, RESULT, SELECTED>>) => Operation<OperationDefinition<ARGS, RESULT, SELECTED>>;
+/**
+ * @deprecated Use `createCommand` instead. Will be removed in v0.6.0.
+ * @see createCommand
+ */
+export declare const createOperation: <ARGS, RESULT, SELECTED = never>(options: import("..").CommandCreateOptions<import("..").CommandDefinition<ARGS, RESULT, SELECTED>>) => import("../core/Command").Command<import("..").CommandDefinition<ARGS, RESULT, SELECTED>>;

package/dist/query/api/createOperation.js

@@ -1,2 +1,6 @@
-import { Operation } from "../../query/core/Opertation/Operation";
-export const createOperation = ((options) => new Operation(options));
+import { createCommand } from "./createCommand";
+/**
+ * @deprecated Use `createCommand` instead. Will be removed in v0.6.0.
+ * @see createCommand
+ */
+export const createOperation = createCommand;

package/dist/query/api/createResource.d.ts

@@ -1,3 +1,3 @@
-import type { ResourceCreateOptions, ResourceDefinition } from "@/query/types";
-import { Resource } from "@/query/core/Resource/Resource";
+import { Resource } from "../../query/core/Resource/Resource";
+import type { ResourceCreateOptions, ResourceDefinition } from "../../query/types";
 export declare const createResource: <ARGS, RESULT, SELECTED = never>(options: ResourceCreateOptions<ResourceDefinition<ARGS, RESULT, SELECTED>>) => Resource<ResourceDefinition<ARGS, RESULT, SELECTED>>;

package/dist/query/api/createResourceDuplicator.d.ts

@@ -1,4 +1,4 @@
-import { DuplicatorOptions, ResourceDuplicator, DuplicatorDefinition } from "@/query/core/Resource/ResourceDuplicator";
-import { ResourceDefinition } from "@/query/types";
+import { DuplicatorDefinition, DuplicatorOptions, ResourceDuplicator } from "../../query/core/Resource/ResourceDuplicator";
+import { ResourceDefinition } from "../../query/types";
 export declare const createResourceDuplicator: <ARGS, RESULT, SELECTED = never>(options: DuplicatorOptions<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>) => ResourceDuplicator<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>;
 export type ResourceDuplicatorCreateFn<ARGS, RESULT, SELECTED = never> = (options: DuplicatorOptions<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>) => ResourceDuplicator<DuplicatorDefinition<ResourceDefinition<ARGS, RESULT, SELECTED>>>;

package/dist/query/core/Command/Command.d.ts

@@ -0,0 +1,35 @@
+import type { ReactiveCache } from "../../../query/lib/ReactiveCache";
+import type { CommandCreateOptions, CommandDefinition, CommandInstance, FallbackOnNever } from "../../../query/types";
+import { CommandAgent } from "./CommandAgent";
+export type CoreCommandQueryState<D extends CommandDefinition> = {
+    arg: D["Args"] | null;
+    data: FallbackOnNever<D["Selected"], D["Result"]> | null;
+    error: unknown | null;
+    isError: boolean;
+    isLoading: boolean;
+    isRepeating: boolean;
+    isDone: boolean;
+    isSuccess: boolean;
+    isInitiated: boolean;
+};
+export declare class Command<D extends CommandDefinition> implements CommandInstance<D> {
+    private readonly _options;
+    private _queriesCache;
+    private _hooks;
+    private _links;
+    private _DEFAULT_CACHE_LIFETIME;
+    constructor(_options: CommandCreateOptions<D>);
+    private _createLinks;
+    createAgent(): CommandAgent<D>;
+    getQueryCache(args: D["Args"]): ReactiveCache<CoreCommandQueryState<D>> | undefined;
+    createQueryCache(args: D["Args"], state?: CoreCommandQueryState<D>): ReactiveCache<CoreCommandQueryState<D>>;
+    initiate(args: D["Args"], options?: {
+        cache?: ReactiveCache<CoreCommandQueryState<D>>;
+    }): ReactiveCache<CoreCommandQueryState<D>>;
+    private _initiate;
+    /**
+     * Используется для обратной совместимости
+     * @deprecated
+     */
+    mutate(args: D["Args"]): Promise<D["Data"]>;
+}

package/dist/query/core/{Opertation/Operation.js → Command/Command.js}

@@ -1,10 +1,10 @@
 import { PromiseResolver } from "../../../common/utils";
+import { ResetAllQueriesSignal } from "../../../query/core/ResetAllQueriesSignal";
 import { Batcher } from "../../../signals";
 import { QueriesCache } from "../QueriesCache";
 import { QueriesLifetimeHooks } from "../QueriesLifetimeHooks";
-import { OperationAgent } from "./OperationAgent";
-import { ResetAllQueriesSignal } from "../../../query/core/ResetAllQueriesSignal";
-class OperationQueryState {
+import { CommandAgent } from "./CommandAgent";
+class CommandQueryState {
     static create() {
         return {
             arg: null,
@@ -18,7 +18,7 @@ class OperationQueryState {
             isInitiated: false,
         };
     }
-    static load(state = OperationQueryState.create(), args) {
+    static load(state = CommandQueryState.create(), args) {
         return {
             ...state,
             arg: args,
@@ -51,7 +51,7 @@ class OperationQueryState {
         };
     }
 }
-export class Operation {
+export class Command {
     _options;
     _queriesCache;
     _hooks;
@@ -69,7 +69,7 @@ export class Operation {
         ResetAllQueriesSignal.clean$.subscribe(() => {
             const caches = Array.from(this._queriesCache.values());
             caches.forEach((cache) => {
-                cache.next(OperationQueryState.create());
+                cache.next(CommandQueryState.create());
             });
         });
     }
@@ -79,12 +79,12 @@ export class Operation {
         });
     }
     createAgent() {
-        return new OperationAgent(this);
+        return new CommandAgent(this);
     }
     getQueryCache(args) {
         return this._queriesCache.getQueryCache(args);
     }
-    createQueryCache(args, state = OperationQueryState.create()) {
+    createQueryCache(args, state = CommandQueryState.create()) {
         const cache = this._queriesCache.createQueryCache(args, state);
         const hookResolvers = this._hooks.onCacheEntryAdded(args);
         const spySub = cache.spy$.subscribe((state) => {
@@ -106,14 +106,14 @@ export class Operation {
     }
     _initiate(args, options) {
         let cache = options?.cache ?? this.getQueryCache(args);
-        const state = OperationQueryState.load(cache?.value, args);
+        const state = CommandQueryState.load(cache?.value, args);
         if (!cache) {
             cache = this.createQueryCache(args, state);
         }
         else {
             cache.next(state);
         }
-        const linksMeta = this._links.map(link => {
+        const linksMeta = this._links.map((link) => {
             const forwardedArgs = link.forwardArgs(args);
             const ref = link.resource.createRef(forwardedArgs);
             return { link, ref, state: {} };
@@ -134,13 +134,12 @@ export class Operation {
             .then((result) => {
             Batcher.run(() => {
                 const data = this._options.select ? this._options.select(result) : result;
-                cache.next(OperationQueryState.success(state, data));
+                cache.next(CommandQueryState.success(state, data));
                 /**
                  * Обновляем связанные ресурсы
                  */
                 linksMeta.forEach(({ link, ref, state }) => {
                     if (link.update && ref.has) {
-                        // TODO подумать, нужно ли добавлять обработку, если patch() -> null (и в принце про работу patch)
                         ref.patch((draft) => {
                             return link.update({ draft, args, data });
                         })?.commit();
@@ -164,7 +163,7 @@ export class Operation {
         })
             .catch((error) => {
             Batcher.run(() => {
-                cache.next(OperationQueryState.error(state, error));
+                cache.next(CommandQueryState.error(state, error));
                 /**
                  * Обновляем связанные ресурсы
                  */
@@ -183,7 +182,7 @@ export class Operation {
         return cache;
     }
     /**
-     * Используеются для обртной совместимости, а надо ли менять что-то - хз
+     * Используется для обратной совместимости
      * @deprecated
      */
     mutate(args) {

package/dist/query/core/Command/CommandAgent.d.ts

@@ -0,0 +1,19 @@
+import type { CommandAgentInstance, CommandDefinition } from "../../../query/types";
+import type { Command } from "./Command";
+export declare class CommandAgent<D extends CommandDefinition> implements CommandAgentInstance<D> {
+    private _command;
+    private _commands$;
+    state$: import("../../../signals").ComputeFn<{
+        isLoading: boolean;
+        isDone: boolean;
+        isSuccess: boolean;
+        isError: boolean;
+        error: {} | undefined;
+        data: NonNullable<import("../../../query/types").FallbackOnNever<D["Selected"], D["Result"]>> | undefined;
+        args: D["Args"];
+    }>;
+    constructor(_command: Command<D>);
+    private _next;
+    initiate(args: D["Args"]): void;
+    createAgent(): CommandAgentInstance<D>;
+}

package/dist/query/core/{Opertation/OperationAgent.js → Command/CommandAgent.js}

@@ -1,12 +1,12 @@
 import { Computed, Signal } from "../../../signals";
-export class OperationAgent {
-    _operation;
-    _operations$ = Signal.create({
+export class CommandAgent {
+    _command;
+    _commands$ = Signal.state({
         current$: null,
     }, { isDisabled: true });
     state$ = Computed.create(() => {
-        const operations = this._operations$.get();
-        const currState = operations.current$?.value$.get();
+        const commands = this._commands$.get();
+        const currState = commands.current$?.value$.get();
         // Нет текущего состояния — дефолт
         if (!currState) {
             return {
@@ -29,26 +29,26 @@ export class OperationAgent {
             args: currState.arg,
         };
     }, { isDisabled: true });
-    constructor(_operation) {
-        this._operation = _operation;
+    constructor(_command) {
+        this._command = _command;
     }
     _next(newCache) {
-        this._operations$.set({
+        this._commands$.set({
             current$: newCache,
         });
     }
     initiate(args) {
-        const cache = this._operation.getQueryCache(args);
+        const cache = this._command.getQueryCache(args);
         if (!cache) {
-            const newCache = this._operation.initiate(args);
+            const newCache = this._command.initiate(args);
             this._next(newCache);
             return;
         }
-        // Всегда запускаем операцию заново, так как операции обычно не кэшируются как ресурсы
-        const newCache = this._operation.initiate(args, { cache });
+        // Всегда запускаем команду заново, так как команды обычно не кэшируются как ресурсы
+        const newCache = this._command.initiate(args, { cache });
         this._next(newCache);
     }
     createAgent() {
-        return new OperationAgent(this._operation);
+        return new CommandAgent(this._command);
     }
 }

package/dist/query/core/Command/index.d.ts

@@ -0,0 +1,2 @@
+export { Command } from "./Command";
+export { CommandAgent } from "./CommandAgent";

package/dist/query/core/Command/index.js

@@ -0,0 +1,2 @@
+export { Command } from "./Command";
+export { CommandAgent } from "./CommandAgent";

package/dist/query/core/Operation/Operation.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @deprecated Use `Command` from '../Command/Command' instead. Will be removed in v0.6.0.
+ */
+export { Command as Operation } from "../Command/Command";
+/**
+ * @deprecated Use `CoreCommandQueryState` from '../Command/Command' instead. Will be removed in v0.6.0.
+ */
+export type { CoreCommandQueryState as CoreOperationQueryState } from "../Command/Command";

package/dist/query/core/Operation/Operation.js

@@ -0,0 +1,4 @@
+/**
+ * @deprecated Use `Command` from '../Command/Command' instead. Will be removed in v0.6.0.
+ */
+export { Command as Operation } from "../Command/Command";

package/dist/query/core/Operation/OperationAgent.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @deprecated Use `CommandAgent` from '../Command/CommandAgent' instead. Will be removed in v0.6.0.
+ */
+export { CommandAgent as OperationAgent } from "../Command/CommandAgent";

package/dist/query/core/Operation/OperationAgent.js

@@ -0,0 +1,4 @@
+/**
+ * @deprecated Use `CommandAgent` from '../Command/CommandAgent' instead. Will be removed in v0.6.0.
+ */
+export { CommandAgent as OperationAgent } from "../Command/CommandAgent";

package/dist/query/core/QueriesCache.d.ts

@@ -1,8 +1,8 @@
-import { ReactiveCache } from "@/query/lib/ReactiveCache";
+import { ReactiveCache } from "../../query/lib/ReactiveCache";
 export declare class QueriesCache<KEY, VALUE> {
     private _cacheLifeTime;
     private readonly _cache;
-    constructor(_cacheLifeTime?: number | false, compareArgsFn?: ((a: KEY, b: KEY) => boolean));
+    constructor(_cacheLifeTime?: number | false, compareArgsFn?: (a: KEY, b: KEY) => boolean);
     getQueryCache(args: KEY): ReactiveCache<VALUE> | undefined;
     createQueryCache(args: KEY, initialState: VALUE): ReactiveCache<VALUE>;
     values(): MapIterator<ReactiveCache<VALUE>>;

package/dist/query/core/QueriesCache.js

@@ -1,6 +1,6 @@
+import { shallowEqual } from "../../common/utils";
 import { IndirectMap } from "../../query/lib/IndirectMap";
 import { ReactiveCache } from "../../query/lib/ReactiveCache";
-import { shallowEqual } from "../../common/utils";
 export class QueriesCache {
     _cacheLifeTime;
     _cache;

package/dist/query/core/QueriesLifetimeHooks.d.ts

@@ -1,5 +1,5 @@
 import { Subject } from "rxjs";
-import { OnCacheEntryAdded, OnQueryStarted } from "@/query/types";
+import { OnCacheEntryAdded, OnQueryStarted } from "../../query/types";
 type Options<ARGS, DATA> = {
     onCacheEntryAdded?: OnCacheEntryAdded<ARGS, DATA>;
     onQueryStarted?: OnQueryStarted<ARGS, DATA>;

package/dist/query/core/QueriesLifetimeHooks.js

@@ -19,15 +19,15 @@ export class QueriesLifetimeHooks {
                 dataChanged$.subscribe((state) => {
                     if (!stateDevtools) {
                         stateDevtools = Devtools.createState(state, {
-                            base: 'Queries',
-                            name: devtoolsName || '',
+                            base: "Queries",
+                            name: devtoolsName || "",
                         });
                         return;
                     }
                     stateDevtools(state);
                 });
                 $cacheEntryRemoved.then(() => {
-                    stateDevtools('$CLEANED');
+                    stateDevtools("$CLEANED");
                 });
             });
         }
@@ -63,7 +63,7 @@ export class QueriesLifetimeHooks {
         const queryFulfilledResolver = new PromiseResolver();
         this.onQueryStartedListeners.forEach((listener) => {
             listener(args, {
-                $queryFulfilled: queryFulfilledResolver.promise
+                $queryFulfilled: queryFulfilledResolver.promise,
             });
         });
         return {
@@ -71,16 +71,16 @@ export class QueriesLifetimeHooks {
                 queryFulfilledResolver.resolve({
                     data,
                     error: undefined,
-                    isError: false
+                    isError: false,
                 });
             },
             fulfilledError: (error) => {
                 queryFulfilledResolver.resolve({
                     data: undefined,
                     error,
-                    isError: true
+                    isError: true,
                 });
-            }
+            },
         };
     };
 }

package/dist/query/core/Resource/Resource.d.ts

@@ -1,12 +1,12 @@
-import { ReactiveCache } from "@/query/lib/ReactiveCache";
-import type { ResourceCreateOptions, ResourceDefinition, ResourceInstance, ResourceRefInstanse, ResourceTransaction } from "@/query/types";
+import { ReactiveCache } from "../../../query/lib/ReactiveCache";
+import type { ResourceCreateOptions, ResourceDefinition, ResourceInstance, ResourceRefInstance, ResourceTransaction } from "../../../query/types";
 import { ResourceAgent } from "./ResourceAgent";
 export type CoreResourceQueryState<D extends ResourceDefinition> = {
     transactions: ResourceTransaction[] | null;
     abortController: AbortController | null;
-    args: D['Args'];
-    savedData: D['Data'] | null;
-    data: D['Data'] | null;
+    args: D["Args"];
+    savedData: D["Data"] | null;
+    data: D["Data"] | null;
     error: unknown | null;
     isError: boolean;
     isLoading: boolean;
@@ -25,27 +25,27 @@ export declare class Resource<D extends ResourceDefinition> implements ResourceI
     private _DEFAULT_CACHE_LIFETIME;
     constructor(_options: ResourceCreateOptions<D>);
     createAgent: () => ResourceAgent<D>;
-    createRef: (args: D["Args"]) => ResourceRefInstanse<D>;
-    getQueryCache(args: D['Args']): CoreResourceQueryCache<D> | undefined;
-    createQueryCache(args: D['Args'], state?: CoreResourceQueryState<D>): CoreResourceQueryCache<D>;
-    incrementLock(args: D['Args'], options?: {
+    createRef: (args: D["Args"]) => ResourceRefInstance<D>;
+    getQueryCache(args: D["Args"]): CoreResourceQueryCache<D> | undefined;
+    createQueryCache(args: D["Args"], state?: CoreResourceQueryState<D>): CoreResourceQueryCache<D>;
+    incrementLock(args: D["Args"], options?: {
         cache?: CoreResourceQueryCache<D>;
     }): CoreResourceQueryCache<D>;
-    decrementLock(args: D['Args'], options?: {
+    decrementLock(args: D["Args"], options?: {
         cache?: CoreResourceQueryCache<D>;
     }): CoreResourceQueryCache<D> | null;
-    update(args: D['Args'], updateFn: (data: D['Data'], savedData: D['Data'] | null, transactions: ResourceTransaction[] | null) => {
-        data: D['Data'];
+    update(args: D["Args"], updateFn: (data: D["Data"], savedData: D["Data"] | null, transactions: ResourceTransaction[] | null) => {
+        data: D["Data"];
         transactions: ResourceTransaction[] | null;
-        savedData: D['Data'] | null;
+        savedData: D["Data"] | null;
     }, options?: {
         cache?: CoreResourceQueryCache<D>;
     }): CoreResourceQueryCache<D> | null;
-    createWithData(args: D['Args'], data: D['Data'], options?: {
+    createWithData(args: D["Args"], data: D["Data"], options?: {
         cache?: CoreResourceQueryCache<D>;
     }): CoreResourceQueryCache<D>;
-    initiate(args: D['Args'], options?: {
+    initiate(args: D["Args"], options?: {
         cache?: CoreResourceQueryCache<D>;
     }): CoreResourceQueryCache<D>;
-    compareArgs(args1: D['Args'], args2: D['Args']): boolean;
+    compareArgs(args1: D["Args"], args2: D["Args"]): boolean;
 }

package/dist/query/core/Resource/Resource.js

@@ -20,7 +20,7 @@ class ResourceQueryState {
             isLocked: false,
             isLoading: false,
             isInitiated: false,
-            lockCount: 0
+            lockCount: 0,
         };
     }
     static load(state, args) {
@@ -66,7 +66,7 @@ class ResourceQueryState {
         return {
             ...state,
             isLocked: lockCount > 0,
-            lockCount
+            lockCount,
         };
     }
     static decrementLock(state) {
@@ -74,7 +74,7 @@ class ResourceQueryState {
         return {
             ...state,
             isLocked: lockCount > 0,
-            lockCount
+            lockCount,
         };
     }
     static update(state, data, savedData, transactions) {
@@ -82,7 +82,7 @@ class ResourceQueryState {
             ...state,
             transactions,
             savedData,
-            data
+            data,
         };
     }
     static createWithData(data, args) {
@@ -100,7 +100,7 @@ class ResourceQueryState {
             args,
             isInitiated: false,
             isLocked: false,
-            lockCount: 0
+            lockCount: 0,
         };
     }
 }
@@ -160,7 +160,7 @@ export class Resource {
         return cache;
     }
     decrementLock(args, options) {
-        let cache = options?.cache ?? this.getQueryCache(args);
+        const cache = options?.cache ?? this.getQueryCache(args);
         if (!cache) {
             return null;
         }
@@ -168,7 +168,7 @@ export class Resource {
         return cache;
     }
     update(args, updateFn, options) {
-        let cache = options?.cache ?? this.getQueryCache(args);
+        const cache = options?.cache ?? this.getQueryCache(args);
         if (!cache) {
             return null;
         }

package/dist/query/core/Resource/ResourceAgent.d.ts

@@ -1,9 +1,9 @@
-import { ResourceAgentInstance, ResourceDefinition } from "@/query/types";
+import { ResourceAgentInstance, ResourceDefinition } from "../../../query/types";
 import type { Resource } from "./Resource";
 export declare class ResourceAgent<D extends ResourceDefinition> implements ResourceAgentInstance<D> {
     private _resource;
     private _resources$;
-    state$: import("../../../signals/types").ComputeFn<{
+    state$: import("../../../signals").ComputeFn<{
         isInitiated: boolean;
         isLoading: boolean;
         isInitialLoading: boolean;

package/dist/query/core/Resource/ResourceAgent.js

@@ -1,7 +1,7 @@
 import { Computed, Signal } from "../../../signals";
 export class ResourceAgent {
     _resource;
-    _resources$ = Signal.create({
+    _resources$ = Signal.state({
         previous$: null,
         current$: null,
     }, { isDisabled: true });
@@ -60,8 +60,8 @@ export class ResourceAgent {
             isError: currState.isError,
             isLocked: currState.isLocked,
             isReloading: currState.isReloading,
-            error: isShowPrev ? prevState.error ?? undefined : currState.error ?? undefined,
-            data: isShowPrev ? prevState.data ?? undefined : currState.data ?? undefined,
+            error: isShowPrev ? (prevState.error ?? undefined) : (currState.error ?? undefined),
+            data: isShowPrev ? (prevState.data ?? undefined) : (currState.data ?? undefined),
             args: currState.args ?? undefined,
         };
     }, { isDisabled: true });

package/dist/query/core/Resource/ResourceDuplicator.d.ts

@@ -1,21 +1,21 @@
-import { ResourceDefinition } from "@/query/types";
-import { CoreResourceQueryState, Resource } from "./Resource";
-import { ReadableSignalLike } from "@/signals/types";
 import { Observable, Subject } from "rxjs";
+import { ResourceDefinition } from "../../../query/types";
+import { ReadableSignalLike } from "../../../signals/types";
+import { CoreResourceQueryState, Resource } from "./Resource";
 import { ResourceDuplicatorAgent } from "./ResourceDuplicatorAgent";
 export type DuplicatorOptions<D extends DuplicatorDefinition> = {
-    resource: Resource<D['RESOURCE_DEFINITION']>;
-    getArgKey: (item: D['ARGS_ITEM']) => string | number;
-    getDataKey: (item: D['DATA_ITEM']) => string | number;
+    resource: Resource<D["RESOURCE_DEFINITION"]>;
+    getArgKey: (item: D["ARGS_ITEM"]) => string | number;
+    getDataKey: (item: D["DATA_ITEM"]) => string | number;
     cacheLifetime?: number | false;
 };
 export type DuplicatorDefinition<D extends ResourceDefinition = ResourceDefinition> = {
-    ARGS_ITEM: D['Args'] extends Array<any> ? D['Args'][number] : never;
-    DATA_ITEM: D['Data'] extends Array<any> ? D['Data'][number] : never;
+    ARGS_ITEM: D["Args"] extends Array<any> ? D["Args"][number] : never;
+    DATA_ITEM: D["Data"] extends Array<any> ? D["Data"][number] : never;
     RESOURCE_DEFINITION: D;
 };
-type State<D extends DuplicatorDefinition> = CoreResourceQueryState<D['RESOURCE_DEFINITION']> & {
-    unreleasedArgs?: D['ARGS_ITEM'][];
+type State<D extends DuplicatorDefinition> = CoreResourceQueryState<D["RESOURCE_DEFINITION"]> & {
+    unreleasedArgs?: D["ARGS_ITEM"][];
 };
 type Cache<D extends DuplicatorDefinition> = ComputedReactiveCache<State<D>>;
 export type CoreResourceDuplicatorCache<D extends DuplicatorDefinition> = Cache<D>;
@@ -25,15 +25,15 @@ export declare class ResourceDuplicator<D extends DuplicatorDefinition> {
     private _caches;
     private get _resource();
     constructor(_options: DuplicatorOptions<D>);
-    getQueryCache(args: D['ARGS_ITEM'][]): Cache<D> | undefined;
-    createCache(args: D['ARGS_ITEM'][]): Cache<D>;
-    initiate(args: D['ARGS_ITEM'][], cache?: Cache<D>): Cache<D>;
-    serialize(args: D['ARGS_ITEM'][]): string;
-    compareArgs(a: D['ARGS_ITEM'][], b: D['ARGS_ITEM'][]): boolean;
+    getQueryCache(args: D["ARGS_ITEM"][]): Cache<D> | undefined;
+    createCache(args: D["ARGS_ITEM"][]): Cache<D>;
+    initiate(args: D["ARGS_ITEM"][], cache?: Cache<D>): Cache<D>;
+    serialize(args: D["ARGS_ITEM"][]): string;
+    compareArgs(a: D["ARGS_ITEM"][], b: D["ARGS_ITEM"][]): boolean;
     createAgent: () => ResourceDuplicatorAgent<D>;
     /** @deprecated */
-    d_init(args: D['ARGS_ITEM'][]): {
-        value$: import("@/signals/types").ComputeFn<State<D>>;
+    d_init(args: D["ARGS_ITEM"][]): {
+        value$: import("../../../signals").ComputeFn<State<D>>;
     };
 }
 export declare class ComputedReactiveCache<T> {