vscroll 1.6.3 → 1.8.0

package/dist/typings/classes/adapter.d.ts

@@ -1,79 +1,79 @@
-import { Logger } from './logger';
-import { Buffer } from './buffer';
-import { Reactive } from './reactive';
-import { Viewport } from './viewport';
-import { WorkflowGetter, AdapterMethodResult, IAdapter, ItemAdapter, ItemsPredicate, AdapterPrependOptions, AdapterAppendOptions, AdapterRemoveOptions, AdapterClipOptions, AdapterInsertOptions, AdapterReplaceOptions, AdapterUpdateOptions, AdapterFixOptions, ScrollerWorkflow, IDatasourceOptional, IPackages, IBufferInfo, State, ProcessSubject } from '../interfaces/index';
-type InitializationParams<Item> = {
-  buffer: Buffer<Item>;
-  state: State;
-  viewport: Viewport;
-  logger: Logger;
-  adapterRun$?: Reactive<ProcessSubject>;
-  getWorkflow?: WorkflowGetter<Item>;
-};
-export declare class Adapter<Item = unknown> implements IAdapter<Item> {
-  private externalContext;
-  private logger;
-  private getWorkflow;
-  private reloadCounter;
-  private source;
-  private box;
-  private demand;
-  private disposed;
-  setFirstOrLastVisible: (_: {
-    first?: boolean;
-    last?: boolean;
-    workflow?: ScrollerWorkflow;
-  }) => void;
-  get workflow(): ScrollerWorkflow<Item>;
-  get reloadCount(): number;
-  get reloadId(): string;
-  id: number;
-  mock: boolean;
-  augmented: boolean;
-  version: string;
-  init: boolean;
-  init$: Reactive<boolean>;
-  packageInfo: IPackages;
-  itemsCount: number;
-  bufferInfo: IBufferInfo;
-  isLoading: boolean;
-  isLoading$: Reactive<boolean>;
-  loopPending: boolean;
-  loopPending$: Reactive<boolean>;
-  firstVisible: ItemAdapter<Item>;
-  firstVisible$: Reactive<ItemAdapter<Item>>;
-  lastVisible: ItemAdapter<Item>;
-  lastVisible$: Reactive<ItemAdapter<Item>>;
-  bof: boolean;
-  bof$: Reactive<boolean>;
-  eof: boolean;
-  eof$: Reactive<boolean>;
-  paused: boolean;
-  paused$: Reactive<boolean>;
-  private relax$;
-  private relaxRun;
-  private getPromisifiedMethod;
-  private getWorkflowRunnerMethod;
-  constructor(context: IAdapter<Item> | null, getWorkflow: WorkflowGetter<Item>, logger: Logger);
-  initialize({ buffer, state, viewport, logger, adapterRun$, getWorkflow }: InitializationParams<Item>): void;
-  dispose(): void;
-  resetContext(): void;
-  reset(options?: IDatasourceOptional): any;
-  reload(options?: number | string): any;
-  append(_options: AdapterAppendOptions<Item> | unknown, eof?: boolean): any;
-  prepend(_options: AdapterPrependOptions<Item> | unknown, bof?: boolean): any;
-  check(): any;
-  remove(options: AdapterRemoveOptions<Item> | ItemsPredicate<Item>): any;
-  clip(options?: AdapterClipOptions): any;
-  insert(options: AdapterInsertOptions<Item>): any;
-  replace(options: AdapterReplaceOptions<Item>): any;
-  update(options: AdapterUpdateOptions<Item>): any;
-  pause(): any;
-  resume(): any;
-  fix(options: AdapterFixOptions<Item>): any;
-  relaxUnchained(callback: (() => void) | undefined, reloadId: string): Promise<AdapterMethodResult>;
-  relax(callback?: () => void): Promise<AdapterMethodResult>;
-  showLog(): void;
-}
-export {};
+import { Logger } from './logger';
+import { Buffer } from './buffer';
+import { Reactive } from './reactive';
+import { Viewport } from './viewport';
+import { WorkflowGetter, AdapterMethodResult, IAdapter, ItemAdapter, ItemsPredicate, AdapterPrependOptions, AdapterAppendOptions, AdapterRemoveOptions, AdapterClipOptions, AdapterInsertOptions, AdapterReplaceOptions, AdapterUpdateOptions, AdapterFixOptions, ScrollerWorkflow, IDatasourceOptional, IPackages, IBufferInfo, State, ProcessSubject } from '../interfaces/index';
+type InitializationParams<Item> = {
+  buffer: Buffer<Item>;
+  state: State;
+  viewport: Viewport;
+  logger: Logger;
+  adapterRun$?: Reactive<ProcessSubject>;
+  getWorkflow?: WorkflowGetter<Item>;
+};
+export declare class Adapter<Item = unknown> implements IAdapter<Item> {
+  private externalContext;
+  private logger;
+  private getWorkflow;
+  private reloadCounter;
+  private source;
+  private box;
+  private demand;
+  private disposed;
+  setFirstOrLastVisible: (_: {
+    first?: boolean;
+    last?: boolean;
+    workflow?: ScrollerWorkflow;
+  }) => void;
+  get workflow(): ScrollerWorkflow<Item>;
+  get reloadCount(): number;
+  get reloadId(): string;
+  id: number;
+  mock: boolean;
+  augmented: boolean;
+  version: string;
+  init: boolean;
+  init$: Reactive<boolean>;
+  packageInfo: IPackages;
+  itemsCount: number;
+  bufferInfo: IBufferInfo;
+  isLoading: boolean;
+  isLoading$: Reactive<boolean>;
+  loopPending: boolean;
+  loopPending$: Reactive<boolean>;
+  firstVisible: ItemAdapter<Item>;
+  firstVisible$: Reactive<ItemAdapter<Item>>;
+  lastVisible: ItemAdapter<Item>;
+  lastVisible$: Reactive<ItemAdapter<Item>>;
+  bof: boolean;
+  bof$: Reactive<boolean>;
+  eof: boolean;
+  eof$: Reactive<boolean>;
+  paused: boolean;
+  paused$: Reactive<boolean>;
+  private relax$;
+  private relaxRun;
+  private getPromisifiedMethod;
+  private getWorkflowRunnerMethod;
+  constructor(context: IAdapter<Item> | null, getWorkflow: WorkflowGetter<Item>, logger: Logger);
+  initialize({ buffer, state, viewport, logger, adapterRun$, getWorkflow }: InitializationParams<Item>): void;
+  dispose(): void;
+  resetContext(): void;
+  reset(options?: IDatasourceOptional): any;
+  reload(options?: number | string): any;
+  append(_options: AdapterAppendOptions<Item> | unknown, eof?: boolean): any;
+  prepend(_options: AdapterPrependOptions<Item> | unknown, bof?: boolean): any;
+  check(): any;
+  remove(options: AdapterRemoveOptions<Item> | ItemsPredicate<Item>): any;
+  clip(options?: AdapterClipOptions): any;
+  insert(options: AdapterInsertOptions<Item>): any;
+  replace(options: AdapterReplaceOptions<Item>): any;
+  update(options: AdapterUpdateOptions<Item>): any;
+  pause(): any;
+  resume(): any;
+  fix(options: AdapterFixOptions<Item>): any;
+  relaxUnchained(callback: (() => void) | undefined, reloadId: string): Promise<AdapterMethodResult>;
+  relax(callback?: () => void): Promise<AdapterMethodResult>;
+  showLog(): void;
+}
+export {};

package/dist/typings/classes/buffer/cache.d.ts

@@ -1,95 +1,94 @@
-import { Item } from '../item';
-import { Settings } from '../settings';
-import { Logger } from '../logger';
-import { SizeStrategy, Direction } from '../../inputs/index';
-interface ItemToCache<Data> {
-  $index: number;
-  data: Data;
-  size?: number;
-}
-interface ItemUpdate {
-  $index: number;
-  size: number;
-  toRemove?: boolean;
-}
-export declare class ItemCache<Data = unknown> {
-  $index: number;
-  data: Data | null;
-  size?: number;
-  position: number;
-  constructor(item: ItemToCache<Data>, saveData: boolean);
-  changeIndex(value: number): void;
-}
-export declare class Cache<Data = unknown> {
-  minIndex: number;
-  maxIndex: number;
-  readonly itemSize: number;
-  readonly saveData: boolean;
-  readonly cacheOnReload: boolean;
-  readonly sizeStrategy: SizeStrategy;
-  readonly logger: Logger;
-  private items;
-  private defaultSize;
-  constructor({ itemSize, cacheData, cacheOnReload, sizeStrategy }: Settings, logger: Logger);
-  reset(force: boolean): void;
-  get size(): number;
-  get(index: number): ItemCache<Data> | undefined;
-  getSizeByIndex(index: number): number;
-  getDefaultSize(): number;
-  recalculateDefaultSize(): boolean;
-  /**
-   * Adds item to Set by $index, replaces existed item if $index matches.
-   * Maintains min/max indexes and default item size.
-   *
-   * @param {Item<Data>} item A Buffer item to be cached, an objects with { $index, data, size } props.
-   *
-   * @returns {ItemCache<Data>} Cached item.
-   */
-  add(item: Item<Data>): ItemCache<Data>;
-  /**
-   * Inserts items to Set, shifts $indexes of items that remain.
-   * Replaces current Set with a new one with new regular $indexes.
-   * Maintains min/max indexes.
-   *
-   * @param {Data[]} toInsert List of non-indexed items to be inserted.
-   * @param {number} index The index before/after which the insertion is performed.
-   * @param {Direction} direction Determines the direction of insertion.
-   * @param {boolean} fixRight Defines indexes shifting strategy.
-   * If false, indexes that are greater than the inserted ones are increased.
-   * If true, indexes that are less than than the inserted ones are decreased.
-   */
-  insertItems(toInsert: Data[], index: number, direction: Direction, fixRight: boolean): void;
-  /**
-   * Removes items from Set, shifts $indexes of items that remain.
-   * Replaces current Set with a new one with new regular $indexes.
-   * Maintains min/max indexes and default item size.
-   *
-   * @param {number[]} toRemove List of indexes to be removed.
-   * @param {boolean} fixRight Defines indexes shifting strategy.
-   * If false, indexes that are greater than the removed ones will be decreased.
-   * If true, indexes that are less than than the removed ones will be increased.
-   */
-  removeItems(toRemove: number[], fixRight: boolean): void;
-  /**
-   * Destructively updates Set based on subset (before-after) changes.
-   * Replaces current Set with a new one with new regular $indexes.
-   * Maintains min/max indexes. Maintains default item size on remove only.
-   *
-   * @param {ItemUpdate[]} before Initial subset of items to be replaced by "after".
-   * Each element is an object with { $index, size, toRemove } props. Must be $index-incremental.
-   * Items to be removed must have toRemove flag: before[].toRemove = true.
-   * @param {Item<Data>[]} after Transformed subset that replaces "before". Must be $index-incremental.
-   * Must contain at least 1 $index from "before" or be empty.
-   * @param {boolean} fixRight This is to fix right indexes during subset collapsing. Acts only if "after" is empty.
-   */
-  updateSubset(before: ItemUpdate[], after: Item<Data>[], fixRight?: boolean): void;
-  /**
-   * Shifts all indexes by some value.
-   * Replaces current Set with a new one with new regular $indexes.
-   * Maintains min/max indexes.
-   *
-   * @param {number} delta A shift value.
-   */
-  shiftIndexes(delta: number): void;
-}
-export {};
+import { Item } from '../item';
+import { Settings } from '../settings';
+import { Logger } from '../logger';
+import { SizeStrategy, Direction } from '../../inputs/index';
+interface ItemToCache<Data> {
+  $index: number;
+  data: Data;
+  size?: number;
+}
+interface ItemUpdate {
+  $index: number;
+  size: number;
+  toRemove?: boolean;
+}
+export declare class ItemCache<Data = unknown> {
+  $index: number;
+  data: Data | null;
+  size?: number;
+  position: number;
+  constructor(item: ItemToCache<Data>, saveData: boolean);
+  changeIndex(value: number): void;
+}
+export declare class Cache<Data = unknown> {
+  minIndex: number;
+  maxIndex: number;
+  readonly itemSize: number;
+  readonly saveData: boolean;
+  readonly cacheOnReload: boolean;
+  readonly sizeStrategy: SizeStrategy;
+  readonly logger: Logger;
+  private items;
+  private defaultSize;
+  constructor({ itemSize, cacheData, cacheOnReload, sizeStrategy }: Settings, logger: Logger);
+  reset(force: boolean): void;
+  get size(): number;
+  get(index: number): ItemCache<Data> | undefined;
+  getSizeByIndex(index: number): number;
+  getDefaultSize(): number;
+  recalculateDefaultSize(): boolean;
+  /**
+   * Adds item to Set by $index, replaces existed item if $index matches.
+   * Maintains min/max indexes and default item size.
+   *
+   * @param {Item<Data>} item A Buffer item to be cached, an objects with { $index, data, size } props.
+   * @returns {ItemCache<Data>} Cached item.
+   */
+  add(item: Item<Data>): ItemCache<Data>;
+  /**
+   * Inserts items to Set, shifts $indexes of items that remain.
+   * Replaces current Set with a new one with new regular $indexes.
+   * Maintains min/max indexes.
+   *
+   * @param {Data[]} toInsert List of non-indexed items to be inserted.
+   * @param {number} index The index before/after which the insertion is performed.
+   * @param {Direction} direction Determines the direction of insertion.
+   * @param {boolean} fixRight Defines indexes shifting strategy.
+   * If false, indexes that are greater than the inserted ones are increased.
+   * If true, indexes that are less than than the inserted ones are decreased.
+   */
+  insertItems(toInsert: Data[], index: number, direction: Direction, fixRight: boolean): void;
+  /**
+   * Removes items from Set, shifts $indexes of items that remain.
+   * Replaces current Set with a new one with new regular $indexes.
+   * Maintains min/max indexes and default item size.
+   *
+   * @param {number[]} toRemove List of indexes to be removed.
+   * @param {boolean} fixRight Defines indexes shifting strategy.
+   * If false, indexes that are greater than the removed ones will be decreased.
+   * If true, indexes that are less than than the removed ones will be increased.
+   */
+  removeItems(toRemove: number[], fixRight: boolean): void;
+  /**
+   * Destructively updates Set based on subset (before-after) changes.
+   * Replaces current Set with a new one with new regular $indexes.
+   * Maintains min/max indexes. Maintains default item size on remove only.
+   *
+   * @param {ItemUpdate[]} before Initial subset of items to be replaced by "after".
+   * Each element is an object with { $index, size, toRemove } props. Must be $index-incremental.
+   * Items to be removed must have toRemove flag: before[].toRemove = true.
+   * @param {Item<Data>[]} after Transformed subset that replaces "before". Must be $index-incremental.
+   * Must contain at least 1 $index from "before" or be empty.
+   * @param {boolean} fixRight This is to fix right indexes during subset collapsing. Acts only if "after" is empty.
+   */
+  updateSubset(before: ItemUpdate[], after: Item<Data>[], fixRight?: boolean): void;
+  /**
+   * Shifts all indexes by some value.
+   * Replaces current Set with a new one with new regular $indexes.
+   * Maintains min/max indexes.
+   *
+   * @param {number} delta A shift value.
+   */
+  shiftIndexes(delta: number): void;
+}
+export {};

package/dist/typings/classes/buffer/checkCall.d.ts

@@ -1,12 +1,12 @@
-import { Buffer } from '../buffer';
-import { Logger } from '../logger';
-import { Direction } from '../../inputs/index';
-import { ItemsPredicate } from '../../interfaces/index';
-export declare class CheckBufferCall<Data> {
-  private context;
-  private logger;
-  constructor(context: Buffer<Data>, logger: Logger);
-  fillEmpty(items: Data[], before?: number, after?: number): boolean;
-  insertInBuffer(predicate?: ItemsPredicate, before?: number, after?: number): number;
-  insertVirtual(items: Data[], index: number, direction: Direction): boolean;
-}
+import { Buffer } from '../buffer';
+import { Logger } from '../logger';
+import { Direction } from '../../inputs/index';
+import { ItemsPredicate } from '../../interfaces/index';
+export declare class CheckBufferCall<Data> {
+  private context;
+  private logger;
+  constructor(context: Buffer<Data>, logger: Logger);
+  fillEmpty(items: Data[], before?: number, after?: number): boolean;
+  insertInBuffer(predicate?: ItemsPredicate, before?: number, after?: number): number;
+  insertVirtual(items: Data[], index: number, direction: Direction): boolean;
+}

package/dist/typings/classes/buffer/defaultSize.d.ts

@@ -1,32 +1,32 @@
-import { SizeStrategy } from '../../inputs/index';
-interface ItemSize {
-  size: number;
-  newSize?: number;
-}
-export declare class SizesRecalculation {
-  newItems: ItemSize[];
-  oldItems: ItemSize[];
-  removed: ItemSize[];
-  constructor();
-  reset(): void;
-}
-export declare class DefaultSize {
-  private readonly itemSize;
-  private readonly sizeStrategy;
-  private sizeMap;
-  private recalculation;
-  private constantSize;
-  private frequentSize;
-  private averageSize;
-  private averageSizeFloat;
-  constructor(itemSize: number, sizeStrategy: SizeStrategy);
-  reset(force: boolean): void;
-  get(): number;
-  private recalculateAverageSize;
-  private recalculateFrequentSize;
-  recalculate(cacheSize: number): boolean;
-  setExisted(oldSize: number, newSize: number): void;
-  setNew(size: number): void;
-  setRemoved(size: number): void;
-}
-export {};
+import { SizeStrategy } from '../../inputs/index';
+interface ItemSize {
+  size: number;
+  newSize?: number;
+}
+export declare class SizesRecalculation {
+  newItems: ItemSize[];
+  oldItems: ItemSize[];
+  removed: ItemSize[];
+  constructor();
+  reset(): void;
+}
+export declare class DefaultSize {
+  private readonly itemSize;
+  private readonly sizeStrategy;
+  private sizeMap;
+  private recalculation;
+  private constantSize;
+  private frequentSize;
+  private averageSize;
+  private averageSizeFloat;
+  constructor(itemSize: number, sizeStrategy: SizeStrategy);
+  reset(force: boolean): void;
+  get(): number;
+  private recalculateAverageSize;
+  private recalculateFrequentSize;
+  recalculate(cacheSize: number): boolean;
+  setExisted(oldSize: number, newSize: number): void;
+  setNew(size: number): void;
+  setRemoved(size: number): void;
+}
+export {};

package/dist/typings/classes/buffer.d.ts

@@ -1,64 +1,64 @@
-import { Item } from './item';
-import { Settings } from './settings';
-import { Logger } from './logger';
-import { Reactive } from './reactive';
-import { Direction } from '../inputs/index';
-import { OnDataChanged, BufferUpdater, ItemsPredicate } from '../interfaces/index';
-export declare class Buffer<Data> {
-  private _items;
-  private _absMinIndex;
-  private _absMaxIndex;
-  bof: Reactive<boolean>;
-  eof: Reactive<boolean>;
-  changeItems: OnDataChanged<Data>;
-  minIndexUser: number;
-  maxIndexUser: number;
-  startIndexUser: number;
-  startIndex: number;
-  private pristine;
-  private cache;
-  private checkCall;
-  private readonly logger;
-  constructor(settings: Settings<Data>, onDataChanged: OnDataChanged<Data>, logger: Logger);
-  dispose(): void;
-  reset(force: boolean, startIndex?: number): void;
-  setCurrentStartIndex(newStartIndex?: unknown): void;
-  set items(items: Item<Data>[]);
-  get items(): Item<Data>[];
-  set absMinIndex(value: number);
-  get absMinIndex(): number;
-  set absMaxIndex(value: number);
-  get absMaxIndex(): number;
-  private checkBOF;
-  private checkEOF;
-  get size(): number;
-  get cacheSize(): number;
-  get defaultSize(): number;
-  get minIndex(): number;
-  get maxIndex(): number;
-  get firstIndex(): number;
-  get lastIndex(): number;
-  get finiteAbsMinIndex(): number;
-  get finiteAbsMaxIndex(): number;
-  get($index: number): Item<Data> | undefined;
-  setItems(items: Item<Data>[]): boolean;
-  clip(): void;
-  getIndexToInsert(predicate?: ItemsPredicate, before?: number, after?: number): number;
-  private shiftExtremum;
-  insertVirtually(items: Data[], index: number, direction: Direction, fixRight: boolean): boolean;
-  removeVirtually(indexes: number[], fixRight: boolean): void;
-  fillEmpty(items: Data[], beforeIndex: number | undefined, afterIndex: number | undefined, fixRight: boolean, generator: (index: number, data: Data) => Item<Data>): boolean;
-  updateItems(predicate: BufferUpdater<Data>, generator: (index: number, data: Data) => Item<Data>, indexToTrack: number, fixRight: boolean): {
-    trackedIndex: number;
-    toRemove: Item<Data>[];
-  };
-  cacheItem(item: Item<Data>): void;
-  getFirstVisibleItemIndex(): number;
-  getLastVisibleItemIndex(): number;
-  getFirstVisibleItem(): Item<Data> | undefined;
-  getLastVisibleItem(): Item<Data> | undefined;
-  getEdgeVisibleItem(direction: Direction, opposite?: boolean): Item<Data> | undefined;
-  getVisibleItemsCount(): number;
-  getSizeByIndex(index: number): number;
-  checkDefaultSize(): boolean;
-}
+import { Item } from './item';
+import { Settings } from './settings';
+import { Logger } from './logger';
+import { Reactive } from './reactive';
+import { Direction } from '../inputs/index';
+import { OnDataChanged, BufferUpdater, ItemsPredicate } from '../interfaces/index';
+export declare class Buffer<Data> {
+  private _items;
+  private _absMinIndex;
+  private _absMaxIndex;
+  bof: Reactive<boolean>;
+  eof: Reactive<boolean>;
+  changeItems: OnDataChanged<Data>;
+  minIndexUser: number;
+  maxIndexUser: number;
+  startIndexUser: number;
+  startIndex: number;
+  private pristine;
+  private cache;
+  private checkCall;
+  private readonly logger;
+  constructor(settings: Settings<Data>, onDataChanged: OnDataChanged<Data>, logger: Logger);
+  dispose(): void;
+  reset(force: boolean, startIndex?: number): void;
+  setCurrentStartIndex(newStartIndex?: unknown): void;
+  set items(items: Item<Data>[]);
+  get items(): Item<Data>[];
+  set absMinIndex(value: number);
+  get absMinIndex(): number;
+  set absMaxIndex(value: number);
+  get absMaxIndex(): number;
+  private checkBOF;
+  private checkEOF;
+  get size(): number;
+  get cacheSize(): number;
+  get defaultSize(): number;
+  get minIndex(): number;
+  get maxIndex(): number;
+  get firstIndex(): number;
+  get lastIndex(): number;
+  get finiteAbsMinIndex(): number;
+  get finiteAbsMaxIndex(): number;
+  get($index: number): Item<Data> | undefined;
+  setItems(items: Item<Data>[]): boolean;
+  clip(): void;
+  getIndexToInsert(predicate?: ItemsPredicate, before?: number, after?: number): number;
+  private shiftExtremum;
+  insertVirtually(items: Data[], index: number, direction: Direction, fixRight: boolean): boolean;
+  removeVirtually(indexes: number[], fixRight: boolean): void;
+  fillEmpty(items: Data[], beforeIndex: number | undefined, afterIndex: number | undefined, fixRight: boolean, generator: (index: number, data: Data) => Item<Data>): boolean;
+  updateItems(predicate: BufferUpdater<Data>, generator: (index: number, data: Data) => Item<Data>, indexToTrack: number, fixRight: boolean): {
+    trackedIndex: number;
+    toRemove: Item<Data>[];
+  };
+  cacheItem(item: Item<Data>): void;
+  getFirstVisibleItemIndex(): number;
+  getLastVisibleItemIndex(): number;
+  getFirstVisibleItem(): Item<Data> | undefined;
+  getLastVisibleItem(): Item<Data> | undefined;
+  getEdgeVisibleItem(direction: Direction, opposite?: boolean): Item<Data> | undefined;
+  getVisibleItemsCount(): number;
+  getSizeByIndex(index: number): number;
+  checkDefaultSize(): boolean;
+}

package/dist/typings/classes/datasource.d.ts

@@ -1,11 +1,11 @@
-import { IDatasourceParams, IDatasourceConstructed, DatasourceGet, Settings, DevSettings, IAdapter, IAdapterConfig } from '../interfaces/index';
-export declare class DatasourceGeneric<Data> implements IDatasourceConstructed<Data> {
-  get: DatasourceGet<Data>;
-  settings?: Settings<Data>;
-  devSettings?: DevSettings;
-  adapter: IAdapter<Data>;
-  constructor(datasource: IDatasourceParams<Data>, config?: IAdapterConfig);
-  dispose(): void;
-}
-export declare const makeDatasource: <DSClassType = typeof DatasourceGeneric>(getConfig?: () => IAdapterConfig) => DSClassType;
-export declare const Datasource: typeof DatasourceGeneric;
+import { IDatasourceParams, IDatasourceConstructed, DatasourceGet, Settings, DevSettings, IAdapter, IAdapterConfig } from '../interfaces/index';
+export declare class DatasourceGeneric<Data> implements IDatasourceConstructed<Data> {
+  get: DatasourceGet<Data>;
+  settings?: Settings<Data>;
+  devSettings?: DevSettings;
+  adapter: IAdapter<Data>;
+  constructor(datasource: IDatasourceParams<Data>, config?: IAdapterConfig);
+  dispose(): void;
+}
+export declare const makeDatasource: <DSClassType = typeof DatasourceGeneric>(getAdapterConfig?: () => IAdapterConfig) => DSClassType;
+export declare const Datasource: typeof DatasourceGeneric;