@typedly/data 4.0.0 → 5.0.0-beta.1

package/README.md

@@ -18,25 +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)
-  - [Interface](#interface)
-    - [`DataAdapter`](#dataadapter)
-    - [`DataConstructor`](#dataconstructor)
-    - [`DataShape`](#datashape)
-    - [`ValueConstructor`](#valueconstructor)
-    - [`ValueShape`](#valueshape)
-  - [Type](#type)
+  - [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)
@@ -44,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
 
@@ -64,164 +83,88 @@ npm install @typedly/data --save-peer
 
 ```typescript
 import {
-  // Interface.
-  DataAdapter,
-  DataConstructor,
-  DataShape,
-  ValueConstructor,
-  ValueShape,
-  // Type.
+  // Inference.
+  InferAsync,
+  InferAsyncOf,
+  InferValue,
+
+  // Iterable.
+  IterValue,
+  IterableElement,
+
+  // Return types
   AsyncReturn,
+  // Config
+  DataConfig,
+  // Input types
   DataConstructorInput,
   DataConstructorTuple,
-  IterValue
+
+  // Iterable
+  IterValue,
+  IterableElement,
+
+  // Value.
+  ValueConstructor,
+  ValueShape,
 } from '@typedly/data';
 ```
 
-### Interface
+### Inference
 
-#### `DataAdapter`
+#### `InferAsyncOf`
 
-The adapter interface for data types.
+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 { DataAdapter } from '@typedly/data';
+import { InferAsync } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/interface/data-adapter.interface.ts)
+[Source](https://github.com/typedly/data/blob/main/src/inference/infer-async-of.type.ts)
 
-#### `DataConstructor`
+#### `InferAsync`
 
-The constructor interface for data types.
+Infers the async flag from the settings `DataSettings` or shape `DataShape`.
 
 ```typescript
-import { DataConstructor, DataShape } from '@typedly/data';
-
-// Import DataShape and DataConstructor.
-// Create a data class that implements `DataShape` of `Type`.
-export class ProfileData<
-  Value extends { age: number, name: string }
-> implements DataShape<Value> {
-
-  public get value(): Value {
-    return {
-      age: this.#age,
-      name: this.#name
-    } as Value;
-  }
-
-  #age;
-  #name;
-  constructor(value: Value, ...args: any[]) {
-    console.log(`Instantiated DataConstructor`, value, ...args);
-    this.#age = value.age;
-    this.#name = value.name;
-  }
-
-  public clear(): this { return this; }
-  public destroy(): this { return this; }
-  public lock(): this { return this; };
-  public getValue(): Value { return this.value; }
-  public setValue(value: Value): this { this.validate(value); return this; }
-  public validate(value: Value): boolean { return true; }
-}
-
-// Create `ProfileClass` with customizable data.
-export class ProfileClass<
-  Value extends { age: number, name: string },
-  DataType extends DataShape<Value>,
-  Args extends any[]
-> {
-
-  public get age(): Value['age'] {
-    return this.#data.value.age;
-  }
-
-  public get name(): Value['name'] {
-    return this.#data.value.name;
-  }
-
-  public get data() {
-    return this.#data;
-  }
-
-  #data: DataType;
-
-  constructor(value: Value, dataCtor: DataConstructor<Value, DataType>);
-  constructor(value: Value, dataCtor: [DataConstructor<Value, DataType>, ...Args]);
-  constructor(value: Value, dataCtor: any) {
-    // ...implementation
-    console.log(`DataConstructor`, value, dataCtor[1]);
-    this.#data = Array.isArray(dataCtor)
-      ? new dataCtor[0](value, ...dataCtor.slice(1))
-      : new dataCtor(value);
-  }
-}
-
-// Initialize.
-// const frankProfile: ProfileClass<object, ProfileData<object>, any[]>
-const frankProfile = new ProfileClass({ age: 37, name: 'Frank' }, ProfileData);
-
-frankProfile.age; // 37
-frankProfile.name; // Frank
-
-// Set the data.
-frankProfile.data.setValue({ age: 37, name: 'Frank' });
-frankProfile.data.clear();
-frankProfile.data.lock();
-frankProfile.data.value;
-
-// Initialize with arguments.
-const markProfile = new ProfileClass(
-  { age: 27, name: 'Mark' },
-  [ProfileData, 'private', true]
-);
+import { InferAsync } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/interface/data-constructor.interface.ts)
+[Source](https://github.com/typedly/data/blob/main/src/inference/infer-async.type.ts)
 
-#### `DataShape`
+#### `InferValue`
 
-The shape of a `Data` type.
+Infers the value type from a data shape interface.
 
 ```typescript
-import { DataShape } from '@typedly/data';
-
-// Create a simple data class with value as property.
-export class TestData<Type> implements DataShape<Type> {
-  get value(): Type { return 27 as Type; }
-  clear(): this { return this; }
-  destroy(): this { return this; }
-  getValue(): Type { return 27 as Type; }
-  lock(): this { return this; };
-  setValue(value: Type): this { return this; }
-  constructor(value: Type, ...args: any[]) {
-    console.log(`Instantiated DataConstructor`, value, ...args);
-  }
-}
+import { InferAsync } from '@typedly/data';
 ```
 
-[Source](https://github.com/typedly/data/blob/main/src/lib/interface/data-shape.interface.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/interface/value-constructor.interface.ts)
+[Source](https://github.com/typedly/data/blob/main/src/iterable/iter-element.type.ts)
 
-#### `ValueShape`
+#### `IterValue`
 
-The shape of a `Value` type.
+The iterated value type.
 
 ```typescript
-import { ValueShape } from '@typedly/data';
+import { IterValue } 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/iterable/iter-value.type.ts)
 
-### Type
+### Data
 
 #### `AsyncReturn`
 
@@ -233,6 +176,16 @@ import { AsyncReturn } from '@typedly/data';
 
 [Source](https://github.com/typedly/data/blob/main/src/lib/type/async-return.type.ts)
 
+#### `DataConfig`
+
+The type for the data configuration, which can be either a full configuration object of `C` or just an async flag.
+
+```typescript
+import { DataConfig } from '@typedly/data';
+```
+
+[Source](https://github.com/typedly/data/blob/main/src/lib/type/data.config.ts)
+
 #### `DataConstructorInput`
 
 The input type for data constructors, with arguments support.
@@ -253,137 +206,56 @@ import { DataConstructorTuple } from '@typedly/data';
 
 [Source](https://github.com/typedly/data/blob/main/src/lib/type/data-constructor-tuple.type.ts)
 
-#### `IterValue`
+#### `DataConstructor`
 
-The iterated value type.
+The constructor interface for data types.
 
 ```typescript
-import { IterValue } from '@typedly/data';
+import { DataConstructor } from '@typedly/data';
+```
+
+[Source](https://github.com/typedly/data/blob/main/src/lib/interface/lib/data.constructor.ts)
+
+#### `DataSettings`
+
+The settings for a data type.
+
+```typescript
+import { DataSettings } from '@typedly/data';
+```
+
+[Source](https://github.com/typedly/data/blob/main/src/lib/interface/lib/data.settings.ts)
+
+#### `DataShape`
+
+The shape of a `Data` type.
+
+```typescript
+import { DataShape } from '@typedly/data';
+```
+
+[Source](https://github.com/typedly/data/blob/main/src/lib/interface/data.shape.ts)
+
+### Value
+
+#### `ValueConstructor`
+
+```typescript
+import { ValueConstructor } 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.constructor.ts)
+
+#### `ValueShape`
 
-### Full example usage
+The shape of a `Value` type.
 
 ```typescript
-import { DataConstructor, DataShape, ValueConstructor, ValueShape } from '@typedly/data';
-
-// Import ValueShape and ValueConstructor.
-// Create a profile data value.
-export class ProfileDataValue<
-  Type extends { age: number, name: string },
-  Args extends any[] = any[]
-> implements ValueShape<Type> {
-  get value(): Type {
-    return {
-      age: this.#age,
-      name: this.#name
-    } as Type;
-  }
-
-  #age: Type['age'];
-  #name: Type['name'];
-
-  constructor(value: Type, ...args: Args) {
-    console.log(`Instantiated ValueConstructor`, value, ...args);
-    this.#age = value.age;
-    this.#name = value.name;
-  }
-
-  set(value: Type): this { return this; }
-}
-
-export class ProfileDataOfValue<
-  Value extends { age: number, name: string },
-  Args extends any[] = any[],
-  ValueInstance extends ValueShape<Value> = ProfileDataValue<Value, Args>,
-> implements DataShape<Value> {
-
-  get value(): Value {
-    return {
-    } as Value;
-  }
-
-  get valueInstance(): ValueInstance {
-    return this.#value;
-  }
-
-  #value;
-  constructor(
-    value: Value,
-    valueCtor: ValueConstructor<Value, ValueInstance, Args> = ProfileDataValue<Value, Args> as any,
-    ...args: Args
-  ) {
-    console.log(`Instantiated DataConstructor`, value, ...args);
-    this.#value = new valueCtor(value, ...args);
-  }
-
-  setValue(value: Value): this { this.validate(value); return this; }
-  getValue(): Value {
-    return this.#value.value;
-  }
-  clear(): this { return this; }
-  destroy(): this { return this; }
-  lock(): this { return this; };
-  validate(value: Value): boolean {
-    return true;
-  }
-}
-
-// const profileDataOfValue: ProfileDataOfValue<{
-//     age: number;
-//     name: string;
-// }, ProfileDataValue<{
-//     age: number;
-//     name: string;
-// }, []>, []>
-const profileDataOfValue = new ProfileDataOfValue({
-  age: 37,
-  name: 'Mark'
-}, ProfileDataValue);
-
-const dataSymbol = Symbol('data');
-
-// Create `ProfileClass` with customizable data.
-export class ProfileClass<
-  Value extends { age: number, name: string },
-  DataType extends DataShape<Value>,
-  Args extends any[]
-> {
-
-  public get age(): Value['age'] {
-    return this.#data.value.age;
-  }
-
-  public get name(): Value['name'] {
-    return this.#data.value.name;
-  }
-
-  public get [dataSymbol]() {
-    return this.#data;
-  }
-
-  #data: DataType;
-
-  constructor(value: Value, dataCtor: DataConstructor<Value, DataType, Args>);
-  constructor(value: Value, dataCtor: [DataConstructor<Value, DataType, Args>, ...Args]);
-  constructor(value: Value, dataCtor: any) {
-    // ...implementation
-    console.log(`DataConstructor`, value, dataCtor[1]);
-    this.#data = Array.isArray(dataCtor)
-      ? new dataCtor[0](value, ...dataCtor.slice(1))
-      : new dataCtor(value);
-  }
-}
-
-const markProfile = new ProfileClass({ age: 37, name: 'Mark' }, ProfileDataOfValue);
-
-markProfile.age // 37
-markProfile.name // Mark
-markProfile[dataSymbol].value // { age, name }
-markProfile[dataSymbol].valueInstance.set({ age: 27, name: 'Frank' });
+import { ValueShape } from '@typedly/data';
 ```
 
+[Source](https://github.com/typedly/data/blob/main/src/value/lib/value-shape.interface.ts)
+
 ## Contributing
 
 Your contributions are valued! If you'd like to contribute, please feel free to submit a pull request. Help is always appreciated.
@@ -394,20 +266,23 @@ If you find this package useful and would like to support its and general develo
 
 Support via:
 
-- [Stripe](https://donate.stripe.com/dR614hfDZcJE3wAcMM)
-- ~~[Revolut](https://checkout.revolut.com/pay/048b10a3-0e10-42c8-a917-e3e9cb4c8e29)~~
-- [GitHub](https://github.com/sponsors/angular-package/sponsorships?sponsor=sciborrudnicki&tier_id=83618)
+- [4Fund](https://4fund.com/bruubs)
 - [DonorBox](https://donorbox.org/become-a-sponsor-to-the-angular-package?default_interval=o)
+- [GitHub](https://github.com/sponsors/angular-package/sponsorships?sponsor=sciborrudnicki&tier_id=83618)
+- [Ko-fi](https://ko-fi.com/sterblack)
+- [OpenCollective](https://opencollective.com/sterblack)
 - [Patreon](https://www.patreon.com/checkout/angularpackage?rid=0&fan_landing=true&view_as=public)
-- [4Fund](https://4fund.com/bruubs)
+- [PayPal](https://paypal.me/sterblack)
+- [Stripe](https://donate.stripe.com/dR614hfDZcJE3wAcMM)
+- ~~[Revolut](https://checkout.revolut.com/pay/048b10a3-0e10-42c8-a917-e3e9cb4c8e29)~~
 
 or via Trust Wallet
 
-- [XLM](https://link.trustwallet.com/send?coin=148&address=GAFFFB7H3LG42O6JA63FJDRK4PP4JCNEOPHLGLLFH625X2KFYQ4UYVM4)
-- [USDT (BEP20)](https://link.trustwallet.com/send?coin=20000714&address=0xA0c22A2bc7E37C1d5992dFDFFeD5E6f9298E1b94&token_id=0x55d398326f99059fF775485246999027B3197955)
-- [ETH](https://link.trustwallet.com/send?coin=60&address=0xA0c22A2bc7E37C1d5992dFDFFeD5E6f9298E1b94)
-- [BTC](https://link.trustwallet.com/send?coin=0&address=bc1qnf709336tfl57ta5mfkf4t9fndhx7agxvv9svn)
 - [BNB](https://link.trustwallet.com/send?coin=20000714&address=0xA0c22A2bc7E37C1d5992dFDFFeD5E6f9298E1b94)
+- [BTC](https://link.trustwallet.com/send?coin=0&address=bc1qnf709336tfl57ta5mfkf4t9fndhx7agxvv9svn)
+- [ETH](https://link.trustwallet.com/send?coin=60&address=0xA0c22A2bc7E37C1d5992dFDFFeD5E6f9298E1b94)
+- [USDT (BEP20)](https://link.trustwallet.com/send?coin=20000714&address=0xA0c22A2bc7E37C1d5992dFDFFeD5E6f9298E1b94&token_id=0x55d398326f99059fF775485246999027B3197955)
+- [XLM](https://link.trustwallet.com/send?coin=148&address=GAFFFB7H3LG42O6JA63FJDRK4PP4JCNEOPHLGLLFH625X2KFYQ4UYVM4)
 
 Thanks for your support!
 
@@ -448,7 +323,7 @@ How do I know when to release 1.0.0?
 
 MIT © typedly ([license][typedly-license])
 
-## Related packages
+## Packages
 
 - **[@typescript-package/chain-descriptor](https://github.com/typescript-package/chain-descriptor)**: A **TypeScript** library for chain property descriptor.
 - **[@typescript-package/controlled-descriptor](https://github.com/typescript-package/controlled-descriptor)**: A **TypeScript** library for controlled property descriptor.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typedly/data",
-  "version": "4.0.0",
+  "version": "5.0.0-beta.1",
   "author": "wwwdev.io <dev@wwwdev.io>",
   "description": "A TypeScript type definitions package for @typescript-package/data.",
   "license": "MIT",
@@ -28,7 +28,27 @@
       "url": "https://donate.stripe.com/dR614hfDZcJE3wAcMM"
     },
     {
-      "type": "revolut",
+      "type": "Donorbox",
+      "url": "https://donorbox.org/become-a-sponsor-to-the-angular-package?default_interval=once&amount=1"
+    },
+    {
+      "type": "Open Collective",
+      "url": "https://opencollective.com/sterblack"
+    },
+    {
+      "type": "Ko-fi",
+      "url": "https://ko-fi.com/sterblack"
+    },
+    {
+      "type": "4Fund",
+      "url": "https://4fund.com/bruubs"
+    },
+    {
+      "type": "paypal",
+      "url": "https://paypal.me/sterblack"
+    },
+    {
+      "type": "individual",
       "url": "https://checkout.revolut.com/pay/048b10a3-0e10-42c8-a917-e3e9cb4c8e29"
     }
   ],

package/types/typedly-data.d.ts

@@ -1,102 +1,203 @@
 import { DataConstructor as DataConstructor$1 } from '@typedly/constructor';
 
 /**
- * @description The conditional return type for async methods.
+ * @description The settings for a data type.
  * @export
- * @template Async The boolean flag indicating if the return type should be a Promise.
- * @template T The type of the value to be returned.
+ * @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;
+}
+
+/**
+ * @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 AsyncReturn<Async, T> = Async extends true ? Promise<T> : T;
+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 Value The value type.
- * @template {DataShape<Value>} Instance The shape of the instance.
- * @template {any[]} [Args=any[]] Additional Arguments passed to the instance.
+ * @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<Value, Instance extends DataShape<Value>, Args extends any[] = any[]> = [DataConstructor<Value, Instance, Args>, ...Args];
+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.
  * @export
- * @template Value The value type.
- * @template {DataShape<Value>} Instance The data instance type.
- * @template {any[]} [Args=any[]] The arguments to pass to instance.
+ * @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=[]] The type of the arguments tuple.
+ */
+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 {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 DataConstructorInput<Value, Instance extends DataShape<Value>, Args extends any[] = any[]> = DataConstructor<Value, Instance, Args> | DataConstructorTuple<Value, Instance, Args>;
+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.
+ * @description The shape of a data type.
  * @export
  * @interface DataShape
  * @template T The value type.
- * @template {boolean} [Async=false] The `Promise` return type for methods.
+ * @template {boolean} [R=false] The async flag.
  */
-interface DataShape<T, Async extends boolean = false> {
-    value: T;
-    clear(): AsyncReturn<Async, this>;
-    destroy(): AsyncReturn<Async, this>;
-    getValue(): AsyncReturn<Async, T>;
-    lock(): this;
-    setValue(value: T): AsyncReturn<Async, this>;
-    [Symbol.toStringTag]?: string;
+interface DataShape<T, R extends boolean = false> {
+    /**
+     * @description Indicates whether the methods return a `Promise`.
+     * @readonly
+     * @type {R}
+     */
+    readonly async: R;
+    /**
+     * @description The value of the `Data` instance.
+     * @readonly
+     * @type {T}
+     */
+    readonly value: T;
+    /**
+     * @description Clears the value of the `Data` instance.
+     * @returns {AsyncReturn<R, this>}
+     */
+    clear(): AsyncReturn<R, this>;
+    /**
+     * @description Destroys the `Data` instance, making it unusable.
+     * @returns {AsyncReturn<R, this>}
+     */
+    destroy(): AsyncReturn<R, this>;
+    /**
+     * @description Gets the value of the `Data` instance.
+     * @returns {AsyncReturn<R, T>}
+     */
+    getValue(): AsyncReturn<R, T>;
+    /**
+     * @description Locks the `Data` instance, preventing any further modifications to its value.
+     * @returns {AsyncReturn<R, this>} The `Data` instance at the time of locking.
+     */
+    lock(): AsyncReturn<R, this>;
+    /**
+     * @description Sets the value of the `Data` instance.
+     * @param {T} value
+     * @returns {AsyncReturn<R, this>}
+     */
+    setValue(value: T): AsyncReturn<R, this>;
+    /**
+     * @description The string tag of the `Data` instance.
+     * @readonly
+     * @type {?string}
+     */
+    readonly [Symbol.toStringTag]?: string;
+    /**
+     * @description The iterator method for the `Data` instance, allowing it to be iterable.
+     * @returns {IterableIterator<IterValue<T>>}
+     */
     [Symbol.iterator]?(): IterableIterator<IterValue<T>>;
+    /**
+     * @description The asynchronous iterator method for the `Data` instance, allowing it to be asynchronously iterable.
+     * @returns {AsyncIterableIterator<IterValue<T>>}
+     */
     [Symbol.asyncIterator]?(): AsyncIterableIterator<IterValue<T>>;
 }
 
 /**
- * @description The adapter interface for data types.
+ * @description The constructor interface for data types.
  * @export
- * @interface DataAdapter
- * @template T The type of the data value.
- * @template {boolean} [R=false] The type of the return values for methods.
- * @extends {DataShape<T, 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 DataAdapter<T, R extends boolean = false> extends DataShape<T, R> {
-    version?: string;
+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 constructor interface for data types.
+ * @description Infers the async flag from the settings `DataSettings` or shape `DataShape`.
  * @export
- * @interface DataConstructor
- * @template Value
- * @template {DataShape<Value>} Instance The instance.
- * @template {readonly any[]} [Args=any[]]
- * @extends {BaseDataConstructor<Value, DataShape<Value>, Instance, [...Args]>}
+ * @template T The type of the configuration object.
+ * @template F The default async flag if it cannot be inferred from T.
  */
-interface DataConstructor<Value, Instance extends DataShape<Value>, Args extends readonly any[] = any[]> extends DataConstructor$1<Value, DataShape<Value>, Instance, [...Args]> {
-}
+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 Infers the async flag from a tuple of arguments, returning true if any of the arguments has an async flag set to true.
+ * @export
+ * @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.
+ */
+type InferAsyncOf<A extends readonly any[], F = false> = A extends [infer Head, ...infer Tail] ? InferAsync<Head> extends true ? true : InferAsyncOf<Tail> : F;
+
+/**
+ * @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
+ * @template I The data shape type.
+ * @template [F=any] The fallback type if inference fails.
+ */
+type InferValue<I, F = any> = I extends DataShape<infer T> ? T : I extends {
+    value?: infer V;
+} ? V : F;
 
 /**
  * @description The value shape.
  * @export
  * @interface ValueShape
- * @template Type The type of value.
+ * @template T The type of value.
  */
-interface ValueShape<Type> {
-    get value(): Type;
-    set(value: Type): this;
+interface ValueShape<T> {
+    get value(): T;
+    set(value: T): this;
 }
 
 /**
  * @description The constructor for value in data for advanced customization.
  * @export
  * @interface ValueConstructor
- * @template Value The value type.
- * @template {ValueShape<Value>} Instance The instance.
- * @template {readonly any[]} [Args=any[]] Additional arguments passed to the constructor.
- * @extends {BaseDataConstructor<Value, ValueShape<Value>, Instance, [...Args]>}
+ * @template T The value type.
+ * @template {ValueShape<T>} I The instance.
+ * @template {readonly any[]} [G=any[]] Additional arguments passed to the constructor.
+ * @extends {BaseDataConstructor<T, ValueShape<T>, I, [...G]>}
  */
-interface ValueConstructor<Value, Instance extends ValueShape<Value>, Args extends readonly any[] = any[]> extends DataConstructor$1<Value, ValueShape<Value>, Instance, [...Args]> {
+interface ValueConstructor<T, I extends ValueShape<T>, G extends readonly any[] = any[]> extends DataConstructor$1<T, ValueShape<T>, I, [...G]> {
 }
 
-export type { AsyncReturn, DataAdapter, DataConstructor, DataConstructorInput, DataConstructorTuple, DataShape, IterValue, ValueConstructor, ValueShape };
+export type { AsyncReturn, DataConfig, DataConstructor, DataConstructorInput, DataConstructorTuple, DataSettings, DataShape, InferAsync, InferAsyncOf, InferValue, IterValue, IterableElement, ValueConstructor, ValueShape };