@typedly/data 3.0.0 → 5.0.0-beta

package/README.md

@@ -25,13 +25,19 @@ A **TypeScript** type definitions package for [**@typescript-package/data**](htt
 
 - [Installation](#installation)
 - [Api](#api)
-  - [Interface](#interface)
-    - [`DataAdapter`](#dataadapter)
+  - [Constructor](#constructor)
+    - [`AdaptableDataConstructor`](#adaptabledataconstructor)
+    - [`DataAdapterConstructor`](#dataadapterconstructor)
     - [`DataConstructor`](#dataconstructor)
-    - [`DataShape`](#datashape)
     - [`ValueConstructor`](#valueconstructor)
+  - [Interface](#interface)
+    - [`AdaptableDataShape`](#adaptabledatashape)
+    - [`DataAdapterShape`](#dataadaptershape)
+    - [`DataShape`](#datashape)
     - [`ValueShape`](#valueshape)
   - [Type](#type)
+    - [`AdaptableDataConstructorInput`](#adaptabledataconstructorinput)
+    - [`AdaptableDataConstructorTuple`](#adaptabledataconstructortuple)
     - [`AsyncReturn`](#asyncreturn)
     - [`DataConstructorInput`](#dataconstructorinput)
     - [`DataConstructorTuple`](#dataconstructortuple)
@@ -64,143 +70,111 @@ npm install @typedly/data --save-peer
 
 ```typescript
 import {
-  // Interface.
-  DataAdapter,
+  // Data adapter constructor.
+  DataAdapterConstructor,
+
+  // Data Constructor.
+  AdaptableDataConstructor,
   DataConstructor,
-  DataShape,
+
+  // Value Constructor.
   ValueConstructor,
+
+  // Data adapter Interface.
+  DataAdapterShape,
+
+  // Data Interface.
+  AdaptableDataShape,
+  DataShape,
+
+  // Value Interface.
   ValueShape,
-  // Type.
-  AsyncReturn,
+
+  // Adaptable data constructor input and tuple.
+  AdaptableDataConstructorInput,
+  AdaptableDataConstructorTuple,
+
+  // Data constructor input and tuple.
   DataConstructorInput,
   DataConstructorTuple,
+
+  // Type.
+  AsyncReturn,
   IterValue
 } from '@typedly/data';
 ```
 
-### Interface
+### Constructor
 
-#### `DataAdapter`
+#### `AdaptableDataConstructor`
 
-The adapter interface for data types.
+The constructor interface for data types with adapter.
 
 ```typescript
-import { DataAdapter } from '@typedly/data';
+import { AdaptableDataConstructor } 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/lib/constructor/lib/adaptable-data.constructor.ts)
+
+#### `DataAdapterConstructor`
+
+The constructor interface for data adapters.
+
+```typescript
+import { DataAdapterConstructor } from '@typedly/data';
+```
+
+[Source](https://github.com/typedly/data/blob/main/src/lib/constructor/lib/data-adapter.constructor.ts)
 
 #### `DataConstructor`
 
 The constructor interface for data types.
 
 ```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> {
-
-  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;
-  }
-
-  set(value: Value): this { this.validate(value); return this; }
-  clear(): this { return this; }
-  destroy(): this { return this; }
-  lock(): this { return this; };
-  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.set({ age: 37, name: 'Frank' });
-frankProfile.data.clear();
-frankProfile.data.lock();
-frankProfile.data.value;
+import { DataConstructor } 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/lib/constructor/lib/data.constructor.ts)
 
-#### `DataShape`
+#### `ValueConstructor`
 
-The shape of a `Data` type.
+```typescript
+import { ValueConstructor } from '@typedly/data';
+```
+
+[Source](https://github.com/typedly/data/blob/main/src/lib/constructor/lib/value.constructor.ts)
+
+### Interface
+
+#### `AdaptableDataShape`
+
+The shape of a data type with optional adapter.
 
 ```typescript
-import { DataShape } from '@typedly/data';
+import { AdaptableDataShape } from '@typedly/data';
+```
 
-class TestData implements DataShape<number> {
-  get value(): number { return this.initialValue; }
-  constructor(private initialValue: number) {}
-  public clear(): this { return this; }
-  public destroy(): this { return this; }
-  public lock(): this { return this; }
-  public set(value: number): this { return this; }
-}
+[Source](https://github.com/typedly/data/blob/main/src/lib/interface/adaptable-data.shape.ts)
+
+#### `DataAdapterShape`
+
+The adapter interface for data types.
+
+```typescript
+import { DataAdapterShape } 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/lib/interface/data-adapter.shape.ts)
 
-#### `ValueConstructor`
+#### `DataShape`
+
+The shape of a `Data` type.
 
 ```typescript
-import { ValueConstructor } from '@typedly/data';
+import { DataShape } 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/lib/interface/data.shape.ts)
 
 #### `ValueShape`
 
@@ -214,6 +188,22 @@ import { ValueShape } from '@typedly/data';
 
 ### Type
 
+#### `AdaptableDataConstructorInput`
+
+```typescript
+import { AdaptableDataConstructorInput } from '@typedly/data';
+```
+
+[Source](https://github.com/typedly/data/blob/main/src/lib/type/adaptable-data-constructor-input.type.ts)
+
+#### `AdaptableDataConstructorTuple`
+
+```typescript
+import { AdaptableDataConstructorTuple } from '@typedly/data';
+```
+
+[Source](https://github.com/typedly/data/blob/main/src/lib/type/adaptable-data-constructor-tuple.type.ts)
+
 #### `AsyncReturn`
 
 The conditional return type for async methods.
@@ -254,124 +244,6 @@ import { IterValue } from '@typedly/data';
 
 [Source](https://github.com/typedly/data/blob/main/src/lib/type/iter-value.type.ts)
 
-### Full example usage
-
-```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);
-  }
-
-  set(value: Value): this { this.validate(value); return this; }
-  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' });
-```
-
 ## Contributing
 
 Your contributions are valued! If you'd like to contribute, please feel free to submit a pull request. Help is always appreciated.
@@ -382,19 +254,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)
+- [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!
 
@@ -437,6 +313,10 @@ 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.
 - **[@typescript-package/controlled-descriptor](https://github.com/typescript-package/controlled-descriptor)**: A **TypeScript** library for controlled property descriptor.
 - **[@typescript-package/controller](https://github.com/typescript-package/controller)**: A **TypeScript** package with for various kind of controllers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typedly/data",
-  "version": "3.0.0",
+  "version": "5.0.0-beta",
   "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,30 +1,46 @@
 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];
+
+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 conditional return type for async methods.
+ * @description The type to provide data constructor with arguments.
  * @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.
+ * @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.
  */
-type AsyncReturn<Async, T> = Async extends true ? Promise<T> : T;
+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];
 
 /**
- * @description The type to provide data constructor with arguments.
+ * @description The input type for data constructors, with arguments support.
  * @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, 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.
  */
-type DataConstructorTuple<Value, Instance extends DataShape<Value>, Args extends any[] = any[]> = [DataConstructor<Value, Instance, Args>, ...Args];
+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>;
 
 /**
- * @description The input type for data constructors, with arguments support.
+ * @description The conditional return type for async methods.
  * @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 Async 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<Async, T> = Async extends true ? Promise<T> : T;
 
 /**
  * @description The iterated value type.
@@ -34,45 +50,101 @@ type DataConstructorInput<Value, Instance extends DataShape<Value>, Args extends
 type IterValue<T> = T extends Iterable<infer U> ? U : 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 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.
  */
-interface DataShape<T, Async extends boolean = false> {
+interface DataShape<T, C, R extends boolean = C extends {
+    async?: boolean;
+} ? C['async'] extends boolean ? C['async'] : false : false> {
+    /**
+     * @description Indicates whether the methods return a `Promise`.
+     * @type {R}
+     */
+    async: R;
+    /**
+     * @description The configuration of the `Data` instance.
+     * @type {?C}
+     */
+    configuration?: C;
+    /**
+     * @description The value of the `Data` instance.
+     * @type {T}
+     */
     value: T;
-    clear(): AsyncReturn<Async, this>;
-    destroy(): AsyncReturn<Async, this>;
+    /**
+     * @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 {this}
+     */
     lock(): this;
-    set(value: T): AsyncReturn<Async, 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.
+     * @type {?string}
+     */
     [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.
  * @export
- * @interface DataAdapter
+ * @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, R>}
+ * @extends {DataShape<T, C, R>}
  */
-interface DataAdapter<T, R extends boolean = false> extends DataShape<T, 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 constructor interface for data types.
+ * @description The shape of a data type with optional adapter.
  * @export
- * @interface DataConstructor
- * @template Value
- * @template {DataShape<Value>} Instance The instance.
- * @template {readonly any[]} [Args=any[]]
- * @extends {BaseDataConstructor<Value, DataShape<Value>, Instance, [...Args]>}
+ * @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<Value, Instance extends DataShape<Value>, Args extends readonly any[] = any[]> extends DataConstructor$1<Value, DataShape<Value>, Instance, [...Args]> {
+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;
 }
 
 /**
@@ -86,16 +158,65 @@ interface ValueShape<Type> {
     set(value: Type): this;
 }
 
+/**
+ * @description The constructor interface for data adapters.
+ * @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.
+ */
+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;
+}
+
+/**
+ * @description The constructor interface for data types with adapter.
+ * @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.
+ */
+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;
+}
+
+/**
+ * @description The constructor interface for data types.
+ * @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 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;
+}
+
 /**
  * @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 { AdaptableDataConstructor, AdaptableDataConstructorInput, AdaptableDataConstructorTuple, AdaptableDataShape, AsyncReturn, DataAdapterConstructor, DataAdapterShape, DataConstructor, DataConstructorInput, DataConstructorTuple, DataShape, IterValue, ValueConstructor, ValueShape };