@typedly/data 5.0.0-beta → 5.0.0-beta.1

package/README.md

@@ -18,31 +18,34 @@ A **TypeScript** type definitions package for [**@typescript-package/data**](htt
 
 ## Features
 
-- **Adapter**: Optional data adapter to customize managing underlying data.
+- **Adapter**: Optional data adapter to customize managing underlying data available under the [`@typedly/adaptable-data`](https://github.com/typedly/data-adapter).
+- **Configurable**: Configurable data shape available under the [`@typedly/configurable-data`](https://github.com/typedly/configurable-data).
+- **Traits**: Extended customization by traits, such as `Configurable`, `Adaptable`, `Serializable`, and `Transformable` under the [`@typedly/data-traits`](https://github.com/typedly/data-traits) package.
 - **Shape**: The default shape for data of any `T` type with conditional async.
 
 ## Table of contents
 
+- [Related packages](#related-packages)
 - [Installation](#installation)
 - [Api](#api)
-  - [Constructor](#constructor)
-    - [`AdaptableDataConstructor`](#adaptabledataconstructor)
-    - [`DataAdapterConstructor`](#dataadapterconstructor)
-    - [`DataConstructor`](#dataconstructor)
-    - [`ValueConstructor`](#valueconstructor)
-  - [Interface](#interface)
-    - [`AdaptableDataShape`](#adaptabledatashape)
-    - [`DataAdapterShape`](#dataadaptershape)
-    - [`DataShape`](#datashape)
-    - [`ValueShape`](#valueshape)
-  - [Type](#type)
-    - [`AdaptableDataConstructorInput`](#adaptabledataconstructorinput)
-    - [`AdaptableDataConstructorTuple`](#adaptabledataconstructortuple)
+  - [Data](#data)
     - [`AsyncReturn`](#asyncreturn)
+    - [`DataConfig`](#dataconfig)
     - [`DataConstructorInput`](#dataconstructorinput)
     - [`DataConstructorTuple`](#dataconstructortuple)
+    - [`DataConstructor`](#dataconstructor)
+    - [`DataSettings`](#datasettings)
+    - [`DataShape`](#datashape)
+  - [Inference](#inference)
+    - [`InferAsyncOf`](#inferasyncof)
+    - [`InferAsync`](#inferasync)
+    - [`InferValue`](#infervalue)
+  - [Iterable](#iterable)
     - [`IterValue`](#itervalue)
-- [Full example usage](#full-example-usage)
+    - [`IterableElement`](#itervalue)
+  - [Value](#value)
+    - [`ValueConstructor`](#valueconstructor)
+    - [`ValueShape`](#valueshape)
 - [Contributing](#contributing)
 - [Support](#support)
 - [Code of Conduct](#code-of-conduct)
@@ -50,7 +53,17 @@ A **TypeScript** type definitions package for [**@typescript-package/data**](htt
   - [Commit](#commit)
   - [Versioning](#versioning)
 - [License](#license)
-- [Related packages](#related-packages)
+- [Packages](#packages)
+
+## Related packages
+
+- **[@typedly/adaptable-data](https://github.com/typedly/adaptable-data)**: A **TypeScript** type definitions for data adapter.
+- **[@typedly/collection](https://github.com/typedly/collection)**: A **TypeScript** type definitions package for data collections with customizable storage.
+- **[@typedly/configurable-data](https://github.com/typedly/configurable-data)**: A **TypeScript** type definitions for configurable data.
+- **[@typedly/data-adapter](https://github.com/typedly/data-adapter)**: A **TypeScript** type definitions for data adapter.
+- **[@typedly/data-traits](https://github.com/typedly/data-traits)**: A **TypeScript** type definitions for data traits.
+- **[@typescript-package/data](https://github.com/typescript-package/data)**: A lightweight **TypeScript** library for basic data management.
+- **[@typescript-package/collection](https://github.com/typescript-package/collection)**: A lightweight **TypeScript** library for data collection.
 
 ## Installation
 
@@ -70,179 +83,178 @@ npm install @typedly/data --save-peer
 
 ```typescript
 import {
-  // Data adapter constructor.
-  DataAdapterConstructor,
-
-  // Data Constructor.
-  AdaptableDataConstructor,
-  DataConstructor,
-
-  // Value Constructor.
-  ValueConstructor,
-
-  // Data adapter Interface.
-  DataAdapterShape,
+  // Inference.
+  InferAsync,
+  InferAsyncOf,
+  InferValue,
 
-  // Data Interface.
-  AdaptableDataShape,
-  DataShape,
+  // Iterable.
+  IterValue,
+  IterableElement,
 
-  // Value Interface.
-  ValueShape,
-
-  // Adaptable data constructor input and tuple.
-  AdaptableDataConstructorInput,
-  AdaptableDataConstructorTuple,
-
-  // Data constructor input and tuple.
+  // Return types
+  AsyncReturn,
+  // Config
+  DataConfig,
+  // Input types
   DataConstructorInput,
   DataConstructorTuple,
 
-  // Type.
-  AsyncReturn,
-  IterValue
+  // Iterable
+  IterValue,
+  IterableElement,
+
+  // Value.
+  ValueConstructor,
+  ValueShape,
 } from '@typedly/data';
 ```
 
-### Constructor
+### Inference
 
-#### `AdaptableDataConstructor`
+#### `InferAsyncOf`
 
-The constructor interface for data types with adapter.
+Infers the async flag from a tuple of arguments, returning true if any of the arguments has an async flag set to true.
 
 ```typescript
-import { AdaptableDataConstructor } from '@typedly/data';
+import { InferAsync } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/constructor/lib/adaptable-data.constructor.ts)
+[Source](https://github.com/typedly/data/blob/main/src/inference/infer-async-of.type.ts)
 
-#### `DataAdapterConstructor`
+#### `InferAsync`
 
-The constructor interface for data adapters.
+Infers the async flag from the settings `DataSettings` or shape `DataShape`.
 
 ```typescript
-import { DataAdapterConstructor } from '@typedly/data';
+import { InferAsync } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/constructor/lib/data-adapter.constructor.ts)
+[Source](https://github.com/typedly/data/blob/main/src/inference/infer-async.type.ts)
 
-#### `DataConstructor`
+#### `InferValue`
 
-The constructor interface for data types.
+Infers the value type from a data shape interface.
 
 ```typescript
-import { DataConstructor } from '@typedly/data';
+import { InferAsync } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/constructor/lib/data.constructor.ts)
+[Source](https://github.com/typedly/data/blob/main/src/inference/infer-value.type.ts)
 
-#### `ValueConstructor`
+### Iterable
+
+#### `IterElement`
+
+The iterate element type.
 
 ```typescript
-import { ValueConstructor } from '@typedly/data';
+import { IterElement } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/constructor/lib/value.constructor.ts)
-
-### Interface
+[Source](https://github.com/typedly/data/blob/main/src/iterable/iter-element.type.ts)
 
-#### `AdaptableDataShape`
+#### `IterValue`
 
-The shape of a data type with optional adapter.
+The iterated value type.
 
 ```typescript
-import { AdaptableDataShape } from '@typedly/data';
+import { IterValue } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/interface/adaptable-data.shape.ts)
+[Source](https://github.com/typedly/data/blob/main/src/iterable/iter-value.type.ts)
 
-#### `DataAdapterShape`
+### Data
 
-The adapter interface for data types.
+#### `AsyncReturn`
+
+The conditional return type for async methods.
 
 ```typescript
-import { DataAdapterShape } from '@typedly/data';
+import { AsyncReturn } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/interface/data-adapter.shape.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/type/async-return.type.ts)
 
-#### `DataShape`
+#### `DataConfig`
 
-The shape of a `Data` type.
+The type for the data configuration, which can be either a full configuration object of `C` or just an async flag.
 
 ```typescript
-import { DataShape } from '@typedly/data';
+import { DataConfig } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/interface/data.shape.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/type/data.config.ts)
 
-#### `ValueShape`
+#### `DataConstructorInput`
 
-The shape of a `Value` type.
+The input type for data constructors, with arguments support.
 
 ```typescript
-import { ValueShape } from '@typedly/data';
+import { DataConstructorInput } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/interface/value-shape.interface.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/type/data-constructor-input.type.ts)
 
-### Type
+#### `DataConstructorTuple`
 
-#### `AdaptableDataConstructorInput`
+The input type for data constructors, with arguments support.
 
 ```typescript
-import { AdaptableDataConstructorInput } from '@typedly/data';
+import { DataConstructorTuple } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/adaptable-data-constructor-input.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/type/data-constructor-tuple.type.ts)
+
+#### `DataConstructor`
 
-#### `AdaptableDataConstructorTuple`
+The constructor interface for data types.
 
 ```typescript
-import { AdaptableDataConstructorTuple } from '@typedly/data';
+import { DataConstructor } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/adaptable-data-constructor-tuple.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/interface/lib/data.constructor.ts)
 
-#### `AsyncReturn`
+#### `DataSettings`
 
-The conditional return type for async methods.
+The settings for a data type.
 
 ```typescript
-import { AsyncReturn } from '@typedly/data';
+import { DataSettings } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/async-return.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/interface/lib/data.settings.ts)
 
-#### `DataConstructorInput`
+#### `DataShape`
 
-The input type for data constructors, with arguments support.
+The shape of a `Data` type.
 
 ```typescript
-import { DataConstructorInput } from '@typedly/data';
+import { DataShape } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/data-constructor-input.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/lib/interface/data.shape.ts)
 
-#### `DataConstructorTuple`
+### Value
 
-The input type for data constructors, with arguments support.
+#### `ValueConstructor`
 
 ```typescript
-import { DataConstructorTuple } from '@typedly/data';
+import { ValueConstructor } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/data-constructor-tuple.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/value/lib/value.constructor.ts)
 
-#### `IterValue`
+#### `ValueShape`
 
-The iterated value type.
+The shape of a `Value` type.
 
 ```typescript
-import { IterValue } from '@typedly/data';
+import { ValueShape } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/type/iter-value.type.ts)
+[Source](https://github.com/typedly/data/blob/main/src/value/lib/value-shape.interface.ts)
 
 ## Contributing
 
@@ -311,10 +323,6 @@ How do I know when to release 1.0.0?
 
 MIT © typedly ([license][typedly-license])
 
-## Related packages
-
-- **[@typescript-package/collection](https://github.com/typescript-package/collection)**: A lightweight TypeScript library for data collection.
-
 ## Packages
 
 - **[@typescript-package/chain-descriptor](https://github.com/typescript-package/chain-descriptor)**: A **TypeScript** library for chain property descriptor.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typedly/data",
-  "version": "5.0.0-beta",
+  "version": "5.0.0-beta.1",
   "author": "wwwdev.io <dev@wwwdev.io>",
   "description": "A TypeScript type definitions package for @typescript-package/data.",
   "license": "MIT",

package/types/typedly-data.d.ts

@@ -1,25 +1,39 @@
 import { DataConstructor as DataConstructor$1 } from '@typedly/constructor';
 
-type AdaptableDataConstructorTuple<A extends DataAdapterShape<T, C, R>, I extends AdaptableDataShape<A, T, C, R>, C extends {
-    async?: boolean;
-} = A extends DataAdapterShape<any, infer V, any> ? V : any, T = A extends DataAdapterShape<infer U, any, any> ? U : any, R extends boolean = A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> = readonly [AdaptableDataConstructor<A, I, C, T, R, G>, ...G];
+/**
+ * @description The settings for a data type.
+ * @export
+ * @interface DataSettings
+ * @template {boolean} [R=false] The async flag.
+ */
+interface DataSettings<R extends boolean = false> {
+    /**
+     * @description Optional async flag to indicate whether the data type is asynchronous.
+     * @default false
+     * @type {?R}
+     */
+    async?: R;
+}
 
-type AdaptableDataConstructorInput<A extends DataAdapterShape<T, C, R>, I extends AdaptableDataShape<A, T, C, R>, C extends {
-    async?: boolean;
-} = A extends DataAdapterShape<any, infer V, any> ? V : any, T = A extends DataAdapterShape<infer U, any, any> ? U : any, R extends boolean = A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> = AdaptableDataConstructor<A, I, C, T, R, G> | AdaptableDataConstructorTuple<A, I, C, T, R, G>;
+/**
+ * @description The type for the data configuration, which can be either a full configuration object of `C` or just an async flag.
+ * @export
+ * @template {DataSettings<R> | undefined} C The type of the settings for configuration.
+ * @template {boolean} [R=InferAsync<C>] The type of the async flag.
+ */
+type DataConfig<C extends DataSettings<R> | undefined, R extends boolean = InferAsync<C>> = C extends DataSettings<R> ? Required<C> : {
+    async: R;
+};
 
 /**
  * @description The type to provide data constructor with arguments.
  * @export
- * @template {DataShape<T, C, R>} I The type of the data instance.
- * @template {{ async?: boolean }} [C=I extends DataShape<any, infer V, any> ? V : any] The type of the configuration, inferred from I if possible.
- * @template [T=I extends DataShape<infer U, any, any> ? U : any] The type of value instance, inferred from I if possible.
- * @template {boolean} [R=I extends DataShape<T, C, infer U> ? U extends boolean ? U : false : false] The type of the readonly flag, inferred from I if possible.
- * @template {readonly any[]} [G=any[]] The type of the arguments tuple.
+ * @template {DataShape<T, R>} I The type of the data instance.
+ * @template [T=InferValue<I>] The type of value instance, inferred from I if possible.
+ * @template {boolean} [R=InferAsync<I>] The type of the readonly flag, inferred from I if possible.
+ * @template {readonly any[]} [G=[]] The type of the arguments tuple.
  */
-type DataConstructorTuple<I extends DataShape<T, C, R>, C extends {
-    async?: boolean;
-} = I extends DataShape<any, infer V, any> ? V : any, T = I extends DataShape<infer U, any, any> ? U : any, R extends boolean = I extends DataShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> = [DataConstructor<I, C, T, R, G>, ...G];
+type DataConstructorTuple<I extends DataShape<T, R>, T = InferValue<I>, R extends boolean = InferAsync<I>, G extends readonly any[] = []> = [DataConstructor<I, T, R, G>, ...G];
 
 /**
  * @description The input type for data constructors, with arguments support.
@@ -28,53 +42,52 @@ type DataConstructorTuple<I extends DataShape<T, C, R>, C extends {
  * @template {{ async?: boolean }} [C=I extends DataShape<any, infer V, any> ? V : any] The type of the configuration, inferred from I if possible.
  * @template [T=I extends DataShape<infer U, any, any> ? U : any] The type of value instance, inferred from I if possible.
  * @template {boolean} [R=I extends DataShape<T, C, infer U> ? U extends boolean ? U : false : false] The type of the readonly flag, inferred from I if possible.
- * @template {readonly any[]} [G=any[]] The type of the arguments tuple.
+ * @template {readonly any[]} [G=[]] The type of the arguments tuple.
  */
-type DataConstructorInput<I extends DataShape<T, C, R>, C extends {
-    async?: boolean;
-} = I extends DataShape<any, infer V, any> ? V : any, T = I extends DataShape<infer U, any, any> ? U : any, R extends boolean = I extends DataShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> = DataConstructor<I, C, T, R, G> | DataConstructorTuple<I, C, T, R, G>;
+type DataConstructorInput<I extends DataShape<T, R>, T = I extends DataShape<infer U, any> ? U : any, R extends boolean = InferAsync<I>, G extends readonly any[] = []> = DataConstructor<I, T, R, G> | DataConstructorTuple<I, T, R, G>;
 
 /**
  * @description The conditional return type for async methods.
  * @export
- * @template Async The boolean flag indicating if the return type should be a Promise.
+ * @template {boolean} R The boolean flag indicating if the return type should be a `Promise`.
  * @template T The type of the value to be returned.
  */
-type AsyncReturn<Async, T> = Async extends true ? Promise<T> : T;
+type AsyncReturn<R extends boolean, T> = R extends true ? Promise<T> : T;
+
+/**
+ * @description The iterate element type.
+ * @export
+ * @template T The type of the iterable.
+ */
+type IterableElement<T> = T extends Iterable<infer U> ? U : T;
 
 /**
  * @description The iterated value type.
  * @export
  * @template T The type of iterated value constrained by the `Iterable` type.
  */
-type IterValue<T> = T extends Iterable<infer U> ? U : T;
+type IterValue<T> = IterableElement<T>;
 
 /**
  * @description The shape of a data type.
  * @export
  * @interface DataShape
  * @template T The value type.
- * @template C The configuration type.
- * @template {boolean} [R=C extends { async?: boolean } ? C['async'] extends boolean ? C['async'] : false : false] The `Promise` return type for methods.
+ * @template {boolean} [R=false] The async flag.
  */
-interface DataShape<T, C, R extends boolean = C extends {
-    async?: boolean;
-} ? C['async'] extends boolean ? C['async'] : false : false> {
+interface DataShape<T, R extends boolean = false> {
     /**
      * @description Indicates whether the methods return a `Promise`.
+     * @readonly
      * @type {R}
      */
-    async: R;
-    /**
-     * @description The configuration of the `Data` instance.
-     * @type {?C}
-     */
-    configuration?: C;
+    readonly async: R;
     /**
      * @description The value of the `Data` instance.
+     * @readonly
      * @type {T}
      */
-    value: T;
+    readonly value: T;
     /**
      * @description Clears the value of the `Data` instance.
      * @returns {AsyncReturn<R, this>}
@@ -92,9 +105,9 @@ interface DataShape<T, C, R extends boolean = C extends {
     getValue(): AsyncReturn<R, T>;
     /**
      * @description Locks the `Data` instance, preventing any further modifications to its value.
-     * @returns {this}
+     * @returns {AsyncReturn<R, this>} The `Data` instance at the time of locking.
      */
-    lock(): this;
+    lock(): AsyncReturn<R, this>;
     /**
      * @description Sets the value of the `Data` instance.
      * @param {T} value
@@ -103,9 +116,10 @@ interface DataShape<T, C, R extends boolean = C extends {
     setValue(value: T): AsyncReturn<R, this>;
     /**
      * @description The string tag of the `Data` instance.
+     * @readonly
      * @type {?string}
      */
-    [Symbol.toStringTag]?: string;
+    readonly [Symbol.toStringTag]?: string;
     /**
      * @description The iterator method for the `Data` instance, allowing it to be iterable.
      * @returns {IterableIterator<IterValue<T>>}
@@ -119,92 +133,59 @@ interface DataShape<T, C, R extends boolean = C extends {
 }
 
 /**
- * @description The adapter interface for data types.
- * @export
- * @interface DataAdapterShape
- * @template T The type of the data value.
- * @template C The type of the configuration object.
- * @template {boolean} [R=false] The type of the return values for methods.
- * @extends {DataShape<T, C, R>}
- */
-interface DataAdapterShape<T, C, R extends boolean = C extends {
-    async?: boolean;
-} ? C['async'] extends boolean ? C['async'] : false : false> extends DataShape<T, C, R> {
-    version?: string;
-}
-
-/**
- * @description The shape of a data type with optional adapter.
+ * @description The constructor interface for data types.
  * @export
- * @interface AdaptableDataShape
- * @template {DataAdapterShape<T, C, any>} A The adapter type.
- * @template [T=A extends DataAdapterShape<infer U, any, any> ? U : any] The value type.
- * @template [C=A extends DataAdapterShape<any, infer V, any> ? V : any] The configuration type.
- * @template {boolean} [R=A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false] The async flag.
- * @extends {DataShape<T, C, R>}
+ * @interface DataConstructor
+ * @template {DataShape<T, R>} I The data instance type.
+ * @template [T=InferValue<I>] The data type inferred from `I`.
+ * @template {boolean} [R=InferAsync<I>] The async flag, inferred from `I` if possible.
+ * @template {readonly any[]} [G=[]] Additional arguments.
  */
-interface AdaptableDataShape<A extends DataAdapterShape<T, C, any> | undefined = undefined, T = A extends DataAdapterShape<infer U, any, any> ? U : any, C = A extends DataAdapterShape<any, infer V, any> ? V : any, R extends boolean = A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false> extends DataShape<T, C, R> {
-    adapter?: A;
+interface DataConstructor<I extends DataShape<T, R>, T = InferValue<I>, R extends boolean = InferAsync<I>, G extends readonly any[] = []> {
+    new (
+    /** The optional initial value for the data instance. */
+    value: T, 
+    /** Additional arguments for the constructor. */
+    ...args: G): I;
 }
 
 /**
- * @description The value shape.
+ * @description Infers the async flag from the settings `DataSettings` or shape `DataShape`.
  * @export
- * @interface ValueShape
- * @template Type The type of value.
+ * @template T The type of the configuration object.
+ * @template F The default async flag if it cannot be inferred from T.
  */
-interface ValueShape<Type> {
-    get value(): Type;
-    set(value: Type): this;
-}
+type InferAsync<T = undefined, F = false> = T extends DataSettings<infer R extends boolean> ? R : T extends DataShape<any, infer R extends boolean> ? R : F;
 
 /**
- * @description The constructor interface for data adapters.
+ * @description Infers the async flag from a tuple of arguments, returning true if any of the arguments has an async flag set to true.
  * @export
- * @interface DataAdapterConstructor
- * @template {DataAdapterShape<T, C, R>} I The data adapter instance type.
- * @template {{ async?: boolean }} [C=I extends DataAdapterShape<any, infer V, any> ? V : any] The configuration type, inferred from I if possible.
- * @template [T=I extends DataAdapterShape<infer U, any, any> ? U : any] The underlying value type, inferred from I if possible.
- * @template {boolean} [R=I extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false] The async flag, inferred from I if possible.
- * @template {readonly any[]} [G=any[]] Additional arguments.
+ * @template {readonly any[]} A The tuple of arguments to infer the async flag from.
+ * @template [F=false] The default async flag value if the tuple is empty.
  */
-interface DataAdapterConstructor<I extends DataAdapterShape<T, C, R>, C extends {
-    async?: boolean;
-} = I extends DataAdapterShape<any, infer V, any> ? V : any, T = I extends DataAdapterShape<infer U, any, any> ? U : any, R extends boolean = I extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> {
-    new (settings: C, value: T, ...args: G): I;
-}
+type InferAsyncOf<A extends readonly any[], F = false> = A extends [infer Head, ...infer Tail] ? InferAsync<Head> extends true ? true : InferAsyncOf<Tail> : F;
 
 /**
- * @description The constructor interface for data types with adapter.
+ * @description Infers the value type from a data shape interface.
+ * It checks if the input type `I` extends `DataShape` and extracts the value type accordingly.
+ * If none of the conditions match, it returns the fallback type `F`.
  * @export
- * @interface AdaptableDataConstructor
- * @template {DataAdapterShape<T, C, R>} A The data adapter instance type.
- * @template {AdaptableDataShape<A, T, C, R>} I The data instance type.
- * @template {{ async?: boolean }} [C=A extends DataAdapterShape<any, infer V, any> ? V : any] The configuration type, inferred from A if possible.
- * @template [T=A extends DataAdapterShape<infer U, any, any> ? U : any] The underlying value type, inferred from A if possible.
- * @template {boolean} [R=A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false] The async flag, inferred from A if possible.
- * @template {readonly any[]} [G=any[]] The additional arguments type.
+ * @template I The data shape type.
+ * @template [F=any] The fallback type if inference fails.
  */
-interface AdaptableDataConstructor<A extends DataAdapterShape<T, C, R>, I extends AdaptableDataShape<A, T, C, R>, C extends {
-    async?: boolean;
-} = A extends DataAdapterShape<any, infer V, any> ? V : any, T = A extends DataAdapterShape<infer U, any, any> ? U : any, R extends boolean = A extends DataAdapterShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> {
-    new (settings: C, value: T, adapter: DataAdapterConstructor<A, C, T, R, G>, ...args: G): I;
-}
+type InferValue<I, F = any> = I extends DataShape<infer T> ? T : I extends {
+    value?: infer V;
+} ? V : F;
 
 /**
- * @description The constructor interface for data types.
+ * @description The value shape.
  * @export
- * @interface DataConstructor
- * @template {DataShape<T, C, R>} I The data instance type.
- * @template {{ async?: boolean }} C The configuration type, inferred from `I` if possible.
- * @template T The underlying value type, inferred from `I` if possible.
- * @template {boolean} [R=C['async'] extends boolean ? C['async'] : false] The async flag, inferred from `I` if possible.
- * @template {readonly any[]} [G=any[]] Additional arguments.
+ * @interface ValueShape
+ * @template T The type of value.
  */
-interface DataConstructor<I extends DataShape<T, C, R>, C extends {
-    async?: boolean;
-} = I extends DataShape<any, infer V, any> ? V : any, T = I extends DataShape<infer U, any, any> ? U : any, R extends boolean = I extends DataShape<T, C, infer U> ? U extends boolean ? U : false : false, G extends readonly any[] = any[]> {
-    new (settings: C, value: T, ...args: G): I;
+interface ValueShape<T> {
+    get value(): T;
+    set(value: T): this;
 }
 
 /**
@@ -219,4 +200,4 @@ interface DataConstructor<I extends DataShape<T, C, R>, C extends {
 interface ValueConstructor<T, I extends ValueShape<T>, G extends readonly any[] = any[]> extends DataConstructor$1<T, ValueShape<T>, I, [...G]> {
 }
 
-export type { AdaptableDataConstructor, AdaptableDataConstructorInput, AdaptableDataConstructorTuple, AdaptableDataShape, AsyncReturn, DataAdapterConstructor, DataAdapterShape, DataConstructor, DataConstructorInput, DataConstructorTuple, DataShape, IterValue, ValueConstructor, ValueShape };
+export type { AsyncReturn, DataConfig, DataConstructor, DataConstructorInput, DataConstructorTuple, DataSettings, DataShape, InferAsync, InferAsyncOf, InferValue, IterValue, IterableElement, ValueConstructor, ValueShape };