ngxs-synchronizers 4.0.0 → 4.0.1

package/fesm2022/ngxs-synchronizers.mjs

@@ -400,21 +400,21 @@ class SyncStore {
     reset(state) {
         return this.store.reset(state);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.6", ngImport: i0, type: SyncStore, deps: [{ token: i0.Injector }, { token: i1.Store }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.6", ngImport: i0, type: SyncStore });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: SyncStore, deps: [{ token: i0.Injector }, { token: i1.Store }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: SyncStore });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.6", ngImport: i0, type: SyncStore, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: SyncStore, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.Store }] });
 
 class NgxsSyncModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.6", ngImport: i0, type: NgxsSyncModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.1.6", ngImport: i0, type: NgxsSyncModule });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.1.6", ngImport: i0, type: NgxsSyncModule, providers: [
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: NgxsSyncModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.6", ngImport: i0, type: NgxsSyncModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: NgxsSyncModule, providers: [
             SyncStore
         ] });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.6", ngImport: i0, type: NgxsSyncModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: NgxsSyncModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [

package/index.d.ts

@@ -1,9 +1,169 @@
-export * from "./module";
-export * from "./state-selector";
-export * from "./sync-store";
-export * from "./synchronizer/collection-synchronizer";
-export * from "./synchronizer/property-synchronizer";
-export * from "./synchronizer/state-synchronizer";
-export * from "./synchronizer/synchronizer";
-export * from "./synchronizer/synchronizer-dictionary";
-export * from "./decorators/sync-state";
+import * as i0 from '@angular/core';
+import { Type, Injector, Signal } from '@angular/core';
+import { Observable, Subscription } from 'rxjs';
+import { Store, TypedSelector } from '@ngxs/store';
+
+declare class NgxsSyncModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsSyncModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsSyncModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsSyncModule>;
+}
+
+interface Synchronizer<T, PropKey extends keyof T, ReadParamsT, WriteParamsT> {
+    requiredProperties?: Array<keyof T>;
+    proxy?: boolean;
+    read(requiredDetails: Partial<T>, options: Synchronizer.BaseOptions<T, PropKey, ReadParamsT> & Synchronizer.ReadOptions<ReadParamsT>): Observable<T[PropKey]>;
+    write?(value: T[PropKey], options: Synchronizer.BaseOptions<T, PropKey, WriteParamsT> & Synchronizer.WriteOptions<WriteParamsT>): Observable<any>;
+}
+declare namespace Synchronizer {
+    interface BaseOptions<T, PropKey extends keyof T, ParamsT> {
+        propertyName: PropKey;
+        requestParams?: ParamsT;
+    }
+    interface ReadOptions<ParamsT> {
+        clearStore?: boolean;
+        requestParams?: ParamsT;
+    }
+    interface WriteOptions<ParamsT> {
+        requestParams?: ParamsT;
+    }
+}
+
+interface CollectionSynchronizer<T, ReadParamsT = never, WriteParamsT = never> extends Synchronizer<T, keyof T, ReadParamsT, WriteParamsT> {
+    read(requiredDetails: Partial<T>, options: CollectionSynchronizer.ReadOptions<T, ReadParamsT>): Observable<T[keyof T]>;
+    write?(value: T[keyof T], options: CollectionSynchronizer.WriteOptions<T, WriteParamsT>): Observable<any>;
+}
+declare namespace CollectionSynchronizer {
+    type ReadOptions<T, ParamsT = never> = Synchronizer.BaseOptions<T, keyof T, ParamsT> & Synchronizer.ReadOptions<ParamsT>;
+    type WriteOptions<T, ParamsT = never> = Synchronizer.BaseOptions<T, keyof T, ParamsT> & Synchronizer.WriteOptions<ParamsT>;
+}
+
+interface PropertySynchronizer<T, PropKey extends keyof T, ReadParamsT = never, WriteParamsT = never> extends Synchronizer<T, PropKey, ReadParamsT, WriteParamsT> {
+    read(requiredDetails: Partial<T>, options: PropertySynchronizer.ReadOptions<T, PropKey, ReadParamsT>): Observable<T[PropKey]>;
+    write?(value: T[PropKey], options: PropertySynchronizer.WriteOptions<T, PropKey, WriteParamsT>): Observable<any>;
+}
+declare namespace PropertySynchronizer {
+    type ReadOptions<T, PropKey extends keyof T = keyof T, ParamsT = never> = Synchronizer.BaseOptions<T, PropKey, ParamsT> & Synchronizer.ReadOptions<ParamsT>;
+    type WriteOptions<T, PropKey extends keyof T = keyof T, ParamsT = never> = Synchronizer.BaseOptions<T, PropKey, ParamsT> & Synchronizer.WriteOptions<ParamsT>;
+}
+
+type SynchronizerDictionary<T> = {
+    [P in keyof T]?: Type<PropertySynchronizer<T, P>>;
+} | Type<CollectionSynchronizer<T>>;
+declare namespace SynchronizerDictionary {
+    function keys<T>(dict: SynchronizerDictionary<T>): Array<keyof T>;
+    function isCollectionSynchronizer<T>(dict: SynchronizerDictionary<T>): dict is Type<CollectionSynchronizer<T>>;
+    function resolveSynchronizer<T>(dict: SynchronizerDictionary<T>, propKey: keyof T): Type<Synchronizer<T, keyof T, unknown, unknown>> | undefined;
+    function resolveSynchronizerInstance<T>(injector: Injector, dict: SynchronizerDictionary<T>, propKey: keyof T): Synchronizer<T, keyof T, unknown, unknown>;
+}
+
+declare const NGXS_SYNCHRONIZERS_METADATA_KEY: unique symbol;
+declare const PARENT_REF_KEY: unique symbol;
+declare const SYNC_STORE_OPTIONS_KEY: unique symbol;
+interface StoreOptions<T> {
+    name: string;
+    defaults?: T;
+    children?: any[];
+}
+interface Metadata<T> {
+    [SYNC_STORE_OPTIONS_KEY]: SyncStoreOptions<T>;
+    [PARENT_REF_KEY]?: any;
+}
+interface SyncStoreOptions<T> extends StoreOptions<T> {
+    synchronizers?: SynchronizerDictionary<T>;
+}
+interface SyncClass<T> extends Type<any> {
+    [NGXS_SYNCHRONIZERS_METADATA_KEY]?: Metadata<T>;
+}
+declare namespace SyncClass {
+    function getStoreOptions<T>($class: SyncClass<T>): SyncStoreOptions<T>;
+    function setStoreOptions<T>($class: SyncClass<T>, options: SyncStoreOptions<T>): void;
+    function resolveParent<T>($class: SyncClass<T>): SyncClass<unknown>;
+    function resolveParents<T>($class: SyncClass<T>): SyncClass<unknown>[];
+    function setParent<T>($childClass: SyncClass<unknown>, $parentClass: SyncClass<T>): void;
+}
+
+type ActionOrArrayOfActions<T> = T extends (infer U)[] ? NonNullable<U>[] : NonNullable<T>;
+declare class SyncStore {
+    readonly injector: Injector;
+    private readonly store;
+    private readonly _selectorMap;
+    constructor(injector: Injector, store: Store);
+    state<T>(syncState: SyncClass<T>): StateSelector<T>;
+    dispatch<T>(actionOrActions: ActionOrArrayOfActions<T>): Observable<void>;
+    select<T>(selector: TypedSelector<T>): Observable<T>;
+    selectOnce<T>(selector: TypedSelector<T>): Observable<T>;
+    selectSnapshot<T>(selector: TypedSelector<T>): T;
+    selectSignal<T>(selector: TypedSelector<T>): Signal<T>;
+    subscribe(fn?: (value: any) => void): Subscription;
+    snapshot(): any;
+    reset(state: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SyncStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SyncStore>;
+}
+
+declare class StateSelector<T> {
+    private store;
+    private stateClass;
+    private state$;
+    readonly synchronizers?: SynchronizerDictionary<T>;
+    private readonly injector;
+    private readonly pendingRequests$;
+    constructor(store: SyncStore, stateClass: SyncClass<T>, state$: Observable<T | undefined>);
+    dispatch<PropT extends keyof T>(propertyName: PropT, value: T[PropT]): Observable<T>;
+    property<PropT extends keyof T>(propertyName: PropT): Observable<T[PropT] | undefined>;
+    properties(): Observable<T | undefined>;
+    definedProperty<PropT extends keyof T>(propertyName: PropT): Observable<T[PropT]>;
+    isSyncingProperty(propertyName: keyof T): Observable<boolean>;
+    onPropertySyncing<PropT extends keyof T>(propertyName: PropT): Observable<PropT>;
+    onPropertySynced<PropT extends keyof T>(propertyName: PropT): Observable<PropT>;
+    onEveryPropertySyncing(...propertyNames: Array<keyof T>): Observable<Array<keyof T>>;
+    onEveryPropertySynced(...propertyNames: Array<keyof T>): Observable<Array<keyof T>>;
+    onSomePropertySyncing(...propertyNames: Array<keyof T>): Observable<keyof T>;
+    onSomePropertySynced(...propertyNames: Array<keyof T>): Observable<keyof T>;
+    require<RequestParamsT = never>(propertyNames: keyof T | Array<keyof T>, options?: Synchronizer.ReadOptions<RequestParamsT>): Observable<T>;
+    requireProperty<PropT extends keyof T, RequestParamsT = never>(propertyName: PropT, options?: Synchronizer.ReadOptions<RequestParamsT>): Observable<T[PropT]>;
+    sync<RequestParamsT = never>(propertyNames: keyof T | Array<keyof T>, options?: Synchronizer.ReadOptions<RequestParamsT>): Observable<T>;
+    syncProperty<PropT extends keyof T, RequestParamsT = never>(propertyName: PropT, options?: Synchronizer.ReadOptions<RequestParamsT>): Observable<T[PropT]>;
+    export<RequestParamsT = never>(propertyNames: keyof T | Array<keyof T>, options?: Synchronizer.WriteOptions<RequestParamsT>): Observable<any>;
+    private requireOne;
+    private requireAll;
+    private syncOne;
+    private syncAll;
+    private exportOne;
+    private exportAll;
+    private getPropertyUpdater;
+    private clearPropertyUpdater;
+    private resolveSynchronizer;
+}
+
+declare abstract class StateSynchronizer<T, PropKey extends keyof T, ReadParamsT = never, WriteParamsT = never> implements PropertySynchronizer<T, PropKey, ReadParamsT, WriteParamsT> {
+    private readonly injector;
+    private readonly propertyState;
+    constructor(injector: Injector, propertyState: SyncClass<T[PropKey]>);
+    read(_requiredDetails: Partial<T>, _options: PropertySynchronizer.ReadOptions<T, PropKey, ReadParamsT>): Observable<T[PropKey]>;
+    protected readSubset(properties: Array<keyof T[PropKey]>): Observable<T[PropKey]>;
+    private readProperties;
+    private readProperty;
+}
+
+declare function SyncState<T>(options: SyncStoreOptions<T>): ClassDecorator;
+declare namespace SyncState {
+    class UpdateAction<StateT, PropertyT extends keyof StateT> {
+        readonly property: PropertyT;
+        readonly payload: StateT[PropertyT];
+        static readonly type: string;
+        constructor(property: PropertyT, payload: StateT[PropertyT]);
+    }
+    namespace UpdateAction {
+        interface Type<StateT, PropertyT extends keyof StateT> {
+            type: string;
+            new (property: PropertyT, payload: StateT[PropertyT]): UpdateAction<StateT, PropertyT>;
+        }
+        export function bootstrapClass<StateT>($class: SyncClass<StateT>): void;
+        export function Type<StateT, PropertyT extends keyof StateT = keyof StateT>($class: SyncClass<StateT>): Type<StateT, PropertyT>;
+        export {};
+    }
+}
+
+export { CollectionSynchronizer, NgxsSyncModule, PropertySynchronizer, StateSelector, StateSynchronizer, SyncState, SyncStore, Synchronizer, SynchronizerDictionary };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngxs-synchronizers",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "Easily keep your app's local state synchronized with your backend, databases and more! ngxs-synchronizers simplifies synchronizing your NGXS-based application state with external data sources.",
   "author": "Mychal Thompson <mychal.r.thompson@gmail.com>",
   "license": "MIT",

package/decorators/sync-class.d.ts

@@ -1,28 +0,0 @@
-import { Type as ClassType } from "@angular/core";
-import { SynchronizerDictionary } from "../synchronizer/synchronizer-dictionary";
-declare const NGXS_SYNCHRONIZERS_METADATA_KEY: unique symbol;
-declare const PARENT_REF_KEY: unique symbol;
-declare const SYNC_STORE_OPTIONS_KEY: unique symbol;
-interface StoreOptions<T> {
-    name: string;
-    defaults?: T;
-    children?: any[];
-}
-interface Metadata<T> {
-    [SYNC_STORE_OPTIONS_KEY]: SyncStoreOptions<T>;
-    [PARENT_REF_KEY]?: any;
-}
-export interface SyncStoreOptions<T> extends StoreOptions<T> {
-    synchronizers?: SynchronizerDictionary<T>;
-}
-export interface SyncClass<T> extends ClassType<any> {
-    [NGXS_SYNCHRONIZERS_METADATA_KEY]?: Metadata<T>;
-}
-export declare namespace SyncClass {
-    function getStoreOptions<T>($class: SyncClass<T>): SyncStoreOptions<T>;
-    function setStoreOptions<T>($class: SyncClass<T>, options: SyncStoreOptions<T>): void;
-    function resolveParent<T>($class: SyncClass<T>): SyncClass<unknown>;
-    function resolveParents<T>($class: SyncClass<T>): SyncClass<unknown>[];
-    function setParent<T>($childClass: SyncClass<unknown>, $parentClass: SyncClass<T>): void;
-}
-export {};

package/decorators/sync-state.d.ts

@@ -1,19 +0,0 @@
-import { SyncClass, SyncStoreOptions } from "./sync-class";
-export declare function SyncState<T>(options: SyncStoreOptions<T>): ClassDecorator;
-export declare namespace SyncState {
-    class UpdateAction<StateT, PropertyT extends keyof StateT> {
-        readonly property: PropertyT;
-        readonly payload: StateT[PropertyT];
-        static readonly type: string;
-        constructor(property: PropertyT, payload: StateT[PropertyT]);
-    }
-    namespace UpdateAction {
-        interface Type<StateT, PropertyT extends keyof StateT> {
-            type: string;
-            new (property: PropertyT, payload: StateT[PropertyT]): UpdateAction<StateT, PropertyT>;
-        }
-        export function bootstrapClass<StateT>($class: SyncClass<StateT>): void;
-        export function Type<StateT, PropertyT extends keyof StateT = keyof StateT>($class: SyncClass<StateT>): Type<StateT, PropertyT>;
-        export {};
-    }
-}

package/module.d.ts

@@ -1,6 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class NgxsSyncModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsSyncModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsSyncModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsSyncModule>;
-}

package/state-selector.d.ts

@@ -1,39 +0,0 @@
-import { Observable } from "rxjs";
-import { SyncClass } from "./decorators/sync-class";
-import { SyncStore } from "./sync-store";
-import { Synchronizer } from "./synchronizer/synchronizer";
-import { SynchronizerDictionary } from "./synchronizer/synchronizer-dictionary";
-export declare class StateSelector<T> {
-    private store;
-    private stateClass;
-    private state$;
-    readonly synchronizers?: SynchronizerDictionary<T>;
-    private readonly injector;
-    private readonly pendingRequests$;
-    constructor(store: SyncStore, stateClass: SyncClass<T>, state$: Observable<T | undefined>);
-    dispatch<PropT extends keyof T>(propertyName: PropT, value: T[PropT]): Observable<T>;
-    property<PropT extends keyof T>(propertyName: PropT): Observable<T[PropT] | undefined>;
-    properties(): Observable<T | undefined>;
-    definedProperty<PropT extends keyof T>(propertyName: PropT): Observable<T[PropT]>;
-    isSyncingProperty(propertyName: keyof T): Observable<boolean>;
-    onPropertySyncing<PropT extends keyof T>(propertyName: PropT): Observable<PropT>;
-    onPropertySynced<PropT extends keyof T>(propertyName: PropT): Observable<PropT>;
-    onEveryPropertySyncing(...propertyNames: Array<keyof T>): Observable<Array<keyof T>>;
-    onEveryPropertySynced(...propertyNames: Array<keyof T>): Observable<Array<keyof T>>;
-    onSomePropertySyncing(...propertyNames: Array<keyof T>): Observable<keyof T>;
-    onSomePropertySynced(...propertyNames: Array<keyof T>): Observable<keyof T>;
-    require<RequestParamsT = never>(propertyNames: keyof T | Array<keyof T>, options?: Synchronizer.ReadOptions<RequestParamsT>): Observable<T>;
-    requireProperty<PropT extends keyof T, RequestParamsT = never>(propertyName: PropT, options?: Synchronizer.ReadOptions<RequestParamsT>): Observable<T[PropT]>;
-    sync<RequestParamsT = never>(propertyNames: keyof T | Array<keyof T>, options?: Synchronizer.ReadOptions<RequestParamsT>): Observable<T>;
-    syncProperty<PropT extends keyof T, RequestParamsT = never>(propertyName: PropT, options?: Synchronizer.ReadOptions<RequestParamsT>): Observable<T[PropT]>;
-    export<RequestParamsT = never>(propertyNames: keyof T | Array<keyof T>, options?: Synchronizer.WriteOptions<RequestParamsT>): Observable<any>;
-    private requireOne;
-    private requireAll;
-    private syncOne;
-    private syncAll;
-    private exportOne;
-    private exportAll;
-    private getPropertyUpdater;
-    private clearPropertyUpdater;
-    private resolveSynchronizer;
-}

package/sync-store.d.ts

@@ -1,25 +0,0 @@
-import { Injector, Signal } from "@angular/core";
-import { Store, TypedSelector } from "@ngxs/store";
-import { SyncClass } from "./decorators/sync-class";
-import { StateSelector } from "./state-selector";
-import { Observable, Subscription } from "rxjs";
-import * as i0 from "@angular/core";
-type ActionOrArrayOfActions<T> = T extends (infer U)[] ? NonNullable<U>[] : NonNullable<T>;
-export declare class SyncStore {
-    readonly injector: Injector;
-    private readonly store;
-    private readonly _selectorMap;
-    constructor(injector: Injector, store: Store);
-    state<T>(syncState: SyncClass<T>): StateSelector<T>;
-    dispatch<T>(actionOrActions: ActionOrArrayOfActions<T>): Observable<void>;
-    select<T>(selector: TypedSelector<T>): Observable<T>;
-    selectOnce<T>(selector: TypedSelector<T>): Observable<T>;
-    selectSnapshot<T>(selector: TypedSelector<T>): T;
-    selectSignal<T>(selector: TypedSelector<T>): Signal<T>;
-    subscribe(fn?: (value: any) => void): Subscription;
-    snapshot(): any;
-    reset(state: any): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SyncStore, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SyncStore>;
-}
-export {};

package/synchronizer/collection-synchronizer.d.ts

@@ -1,10 +0,0 @@
-import { Observable } from "rxjs";
-import { Synchronizer } from "./synchronizer";
-export interface CollectionSynchronizer<T, ReadParamsT = never, WriteParamsT = never> extends Synchronizer<T, keyof T, ReadParamsT, WriteParamsT> {
-    read(requiredDetails: Partial<T>, options: CollectionSynchronizer.ReadOptions<T, ReadParamsT>): Observable<T[keyof T]>;
-    write?(value: T[keyof T], options: CollectionSynchronizer.WriteOptions<T, WriteParamsT>): Observable<any>;
-}
-export declare namespace CollectionSynchronizer {
-    type ReadOptions<T, ParamsT = never> = Synchronizer.BaseOptions<T, keyof T, ParamsT> & Synchronizer.ReadOptions<ParamsT>;
-    type WriteOptions<T, ParamsT = never> = Synchronizer.BaseOptions<T, keyof T, ParamsT> & Synchronizer.WriteOptions<ParamsT>;
-}

package/synchronizer/property-synchronizer.d.ts

@@ -1,10 +0,0 @@
-import { Observable } from "rxjs";
-import { Synchronizer } from "./synchronizer";
-export interface PropertySynchronizer<T, PropKey extends keyof T, ReadParamsT = never, WriteParamsT = never> extends Synchronizer<T, PropKey, ReadParamsT, WriteParamsT> {
-    read(requiredDetails: Partial<T>, options: PropertySynchronizer.ReadOptions<T, PropKey, ReadParamsT>): Observable<T[PropKey]>;
-    write?(value: T[PropKey], options: PropertySynchronizer.WriteOptions<T, PropKey, WriteParamsT>): Observable<any>;
-}
-export declare namespace PropertySynchronizer {
-    type ReadOptions<T, PropKey extends keyof T = keyof T, ParamsT = never> = Synchronizer.BaseOptions<T, PropKey, ParamsT> & Synchronizer.ReadOptions<ParamsT>;
-    type WriteOptions<T, PropKey extends keyof T = keyof T, ParamsT = never> = Synchronizer.BaseOptions<T, PropKey, ParamsT> & Synchronizer.WriteOptions<ParamsT>;
-}

package/synchronizer/state-synchronizer.d.ts

@@ -1,13 +0,0 @@
-import { Injector } from "@angular/core";
-import { Observable } from "rxjs";
-import { SyncClass } from "../decorators/sync-class";
-import { PropertySynchronizer } from "./property-synchronizer";
-export declare abstract class StateSynchronizer<T, PropKey extends keyof T, ReadParamsT = never, WriteParamsT = never> implements PropertySynchronizer<T, PropKey, ReadParamsT, WriteParamsT> {
-    private readonly injector;
-    private readonly propertyState;
-    constructor(injector: Injector, propertyState: SyncClass<T[PropKey]>);
-    read(_requiredDetails: Partial<T>, _options: PropertySynchronizer.ReadOptions<T, PropKey, ReadParamsT>): Observable<T[PropKey]>;
-    protected readSubset(properties: Array<keyof T[PropKey]>): Observable<T[PropKey]>;
-    private readProperties;
-    private readProperty;
-}

package/synchronizer/synchronizer-dictionary.d.ts

@@ -1,13 +0,0 @@
-import { Injector, Type } from "@angular/core";
-import { CollectionSynchronizer } from "./collection-synchronizer";
-import { PropertySynchronizer } from "./property-synchronizer";
-import { Synchronizer } from "./synchronizer";
-export type SynchronizerDictionary<T> = {
-    [P in keyof T]?: Type<PropertySynchronizer<T, P>>;
-} | Type<CollectionSynchronizer<T>>;
-export declare namespace SynchronizerDictionary {
-    function keys<T>(dict: SynchronizerDictionary<T>): Array<keyof T>;
-    function isCollectionSynchronizer<T>(dict: SynchronizerDictionary<T>): dict is Type<CollectionSynchronizer<T>>;
-    function resolveSynchronizer<T>(dict: SynchronizerDictionary<T>, propKey: keyof T): Type<Synchronizer<T, keyof T, unknown, unknown>> | undefined;
-    function resolveSynchronizerInstance<T>(injector: Injector, dict: SynchronizerDictionary<T>, propKey: keyof T): Synchronizer<T, keyof T, unknown, unknown>;
-}

package/synchronizer/synchronizer.d.ts

@@ -1,20 +0,0 @@
-import { Observable } from "rxjs";
-export interface Synchronizer<T, PropKey extends keyof T, ReadParamsT, WriteParamsT> {
-    requiredProperties?: Array<keyof T>;
-    proxy?: boolean;
-    read(requiredDetails: Partial<T>, options: Synchronizer.BaseOptions<T, PropKey, ReadParamsT> & Synchronizer.ReadOptions<ReadParamsT>): Observable<T[PropKey]>;
-    write?(value: T[PropKey], options: Synchronizer.BaseOptions<T, PropKey, WriteParamsT> & Synchronizer.WriteOptions<WriteParamsT>): Observable<any>;
-}
-export declare namespace Synchronizer {
-    interface BaseOptions<T, PropKey extends keyof T, ParamsT> {
-        propertyName: PropKey;
-        requestParams?: ParamsT;
-    }
-    interface ReadOptions<ParamsT> {
-        clearStore?: boolean;
-        requestParams?: ParamsT;
-    }
-    interface WriteOptions<ParamsT> {
-        requestParams?: ParamsT;
-    }
-}