@typedly/data-traits 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 typedly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,532 @@
+<a href="https://github.com/typescript-package">
+  <img
+    src="https://avatars.githubusercontent.com/u/189665258?s=150&u=712e292bae048947d1f7d2020d7d38875c40e63a&v=4"
+    title="@typedly/data-traits - A TypeScript type definitions package for configurable data traits, providing various kinds of configurable data interfaces."
+  />
+</a>
+
+## @typedly/data-traits
+
+<!-- npm badge -->
+[![npm version][package-npm-badge-svg]][package-npm-badge]
+[![GitHub issues][package-badge-issues]][package-issues]
+[![GitHub license][package-badge-license]][package-license]
+
+<!-- GitHub badges -->
+[![GitHub issues][package-badge-issues]][package-issues]
+[![GitHub forks][package-badge-forks]][package-forks]
+[![GitHub stars][package-badge-stars]][package-stars]
+[![GitHub license][package-badge-license]][package-license]
+
+<!-- Sponsors -->
+[![GitHub Sponsors][github-badge-sponsor]][github-sponsor-link]
+[![Patreon Sponsors][patreon-badge]][patreon-link]
+
+A **TypeScript** type definitions package for configurable data traits, providing various kinds of configurable data interfaces.
+
+## Features
+
+- **Adaptable**: Use custom adapters to define how data is stored and retrieved (localStorage, API, memory, etc.)
+- **Cacheable**: Built-in caching support with configurable expiration and refresh capabilities
+- **Cleanable**: Clear data, and cleanup resources
+- **Cloneable**: Create deep, or shallow copies of data instances
+- **Collection**: Base collection shape
+- **Comparable**: Compare data instances for equality and ordering
+- **Compressible**: Compress and decompress data
+- **Configurable**: Flexible configuration system for customizing data behavior and constraints
+- **Encryptable**: Encrypt and decrypt sensitive data with built-in security support
+- **Exportable**: Export data to multiple formats (JSON, XML, CSV, etc.)
+- **Freezable**: Control immutability by freezing and unfreezing data instances
+- **Identifiable**: Identify data object by tag or `ID`
+- **Indexable**: Access and manage data elements by numeric or key-based indices
+- **Measurable**: Track data size, memory usage, and performance metrics
+- **Mergeable**: Merge data from multiple sources with customizable merge strategies
+- **Observable**: Subscribe to data changes with reactive programming support
+- **Paginated**: Navigate large datasets with page-based chunking and iteration
+- **Persistable**: Persist data to storage automatically with **save**/**load** capabilities
+- **Printable**: Format and output data in human-readable formats for display or debugging
+- **Queryable**: Query and filter complex data structures with predicate functions
+- **Resettable**: Reset data to initial state and track modifications
+- **Revertible**: Undo changes and revert to previous states with rollback support
+- **Serializable**: Serialize and deserialize data values with async support
+- **Timestamped**: Automatic tracking of creation, modification, and access times
+- **Transformable**: Transform values with `map` and `flatMap` operations
+- **Validatable**: Comprehensive validation system with custom validators and error reporting
+- **Versionable**: Version control with history tracking, snapshots, and rollback support
+
+## Table of contents
+
+- [Related packages](#related-packages)
+- [Installation](#installation)
+- [Api](#api)
+  - Interface
+    - [`Adaptable`](#adaptable)
+    - [`Cacheable`](#cacheable)
+    - [`Cleanable`](#cleanable)
+    - [`Cloneable`](#cloneable)
+    - [`Collection`](#collection)
+    - [`Comparable`](#comparable)
+    - [`Compressible`](#compressible)
+    - [`Configurable`](#configurable)
+    - [`Encryptable`](#encryptable)
+    - [`Exportable`](#exportable)
+    - [`Freezable`](#freezable)
+    - [`Identifiable`](#identifiable)
+    - [`Indexable`](#indexable)
+    - [`Measurable`](#measurable)
+    - [`Mergeable`](#mergeable)
+    - [`Observable`](#observable)
+    - [`Paginated`](#paginated)
+    - [`Persistable`](#persistable)
+    - [`Printable`](#printable)
+    - [`Queryable`](#queryable)
+    - [`Resettable`](#resettable)
+    - [`Revertible`](#revertible)
+    - [`Serializable`](#serializable)
+    - [`Timestamped`](#timestamped)
+    - [`Transformable`](#transformable)
+    - [`Validatable`](#validatable)
+    - [`Versionable`](#versionable)
+- [Contributing](#contributing)
+- [Support](#support)
+- [Code of Conduct](#code-of-conduct)
+- [Git](#git)
+  - [Commit](#commit)
+  - [Versioning](#versioning)
+- [License](#license)
+- [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](https://github.com/typedly/data)**: A **TypeScript** type definitions for [`@typescript-package/data`](https://github.com/typedly/data).
+- **[@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
+
+```bash
+npm install @typedly/data-traits --save-peer
+```
+
+## Api
+
+```typescript
+import {
+  // Interface.
+  Adaptable,
+  Cacheable,
+  Collection,
+  Comparable,
+  Compressible,
+  Configurable,
+  Encryptable,
+  Exportable,
+  Freezable,
+  Identifiable,
+  Indexable,
+  Measurable,
+  Mergeable,
+  Observable,
+  Paginated,
+  Persistable,
+  Printable,
+  Queryable,
+  Resettable,
+  Revertible,
+  Serializable,
+  Timestamped,
+  Transformable,
+  Validatable,
+  Versionable,
+} from '@typedly/data-traits';
+```
+
+### Interface
+
+### `Adaptable`
+
+The interface for adaptable data types, which can optionally use a data adapter to manage their value and behavior.
+
+```typescript
+import { Adaptable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/adaptable.trait.ts)
+
+### `Cacheable`
+
+The interface for cacheable data types, which can be cached with an optional expiration time and invalidated or refreshed as needed.
+
+```typescript
+import { Cacheable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/cacheable.trait.ts)
+
+### `Cleanable`
+
+Capability for objects that can be cleaned or cleared.
+
+```typescript
+import { Cleanable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/cleanable.trait.ts)
+
+### `Cloneable`
+
+Capability for objects that can be cloned.
+
+```typescript
+import { Cloneable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/cloneable.trait.ts)
+
+### `Collection`
+
+Comparable interface for data types that can be compared.
+
+```typescript
+import { Collection } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/collection.trait.ts)
+
+### `Comparable`
+
+Comparable interface for data types that can be compared.
+
+```typescript
+import { Comparable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/comparable.trait.ts)
+
+### `Compressible`
+
+Interface for data types that can be compressed and decompressed, allowing for efficient storage and transmission of data.
+
+```typescript
+import { Compressible } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/compressible.trait.ts)
+
+### `Configurable`
+
+The interface for configurable data types, which can optionally have a configuration object.
+
+```typescript
+import { Configurable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/configurable.trait.ts)
+
+### `Encryptable`
+
+Interface for data types that can be encrypted and decrypted.
+
+```typescript
+import { Encryptable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/encryptable.trait.ts)
+
+### `Exportable`
+
+The interface for exportable data types, which can be exported to various formats.
+
+```typescript
+import { Exportable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/exportable.trait.ts)
+
+### `Freezable`
+
+The interface for freezable data types, which can be frozen to prevent modifications and optionally unfrozen.
+
+```typescript
+import { Freezable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/freezable.trait.ts)
+
+### `Identifiable`
+
+Trait for objects that have an ID or unique identifier.x
+
+```typescript
+import { Identifiable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/identifiable.trait.ts)
+
+### `Indexable`
+
+Trait for objects that support indexing or retrieving by `numeric` or `string` index.
+
+```typescript
+import { Indexable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/indexable.trait.ts)
+
+### `Measurable`
+
+Interface for data types that can be measured in terms of size and memory usage, allowing for efficient management of resources and optimization of performance.
+
+```typescript
+import { Measurable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/measurable.trait.ts)
+
+### `Mergeable`
+
+The interface for mergeable data types, which can be combined with other instances of the same type using a defined strategy.
+
+```typescript
+import { Mergeable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/mergeable.trait.ts)
+
+### `Observable`
+
+The interface for observable data types, which allow subscribers to be notified of changes to their value.
+
+```typescript
+import { Observable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/observable.trait.ts)
+
+### `Paginated`
+
+Trait for objects that support pagination.
+
+```typescript
+import { Paginated } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/paginated.trait.ts)
+
+### `Persistable`
+
+Trait for objects that can be persisted and restored.
+
+```typescript
+import { Persistable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/persistable.trait.ts)
+
+### `Printable`
+
+Trait for objects that can be printed as a `string` or in a formatted way.
+
+```typescript
+import { Printable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/printable.trait.ts)
+
+### `Queryable`
+
+Interfaces for data types that can be queried using a defined query format, allowing for flexible and efficient retrieval of information based on specific criteria.
+
+```typescript
+import { Queryable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/queryable.trait.ts)
+
+### `Resettable`
+
+Interface for data types that can be reset to an initial value and track if they have been modified (dirty state).
+
+```typescript
+import { Resettable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/resettable.trait.ts)
+
+### `Revertible`
+
+Trait for objects that can revert or undo changes.
+
+```typescript
+import { Revertible } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/revertible.trait.ts)
+
+### `Serializable`
+
+Serializable interface for data types that can be serialized and deserialized.
+
+```typescript
+import { Serializable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/serializable.trait.ts)
+
+### `Timestamped`
+
+Interface representing timestamped data.
+
+```typescript
+import { Timestamped } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/timestamped.trait.ts)
+
+### `Transformable`
+
+Transformable interface for data types that can be transformed.
+
+```typescript
+import { Transformable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/transformable.trait.ts)
+
+### `Validatable`
+
+Interface for data types that can be validated with custom rules and track validation errors.
+
+```typescript
+import { Validatable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/validatable.trait.ts)
+
+### `Versionable`
+
+The interface for versionable data types, which maintain a history of changes and can revert to previous versions.
+
+```typescript
+import { Versionable } from '@typedly/data-traits';
+```
+
+[Source](https://github.com/typedly/data-traits/blob/main/src/lib/versionable.trait.ts)
+
+## Contributing
+
+Your contributions are valued! If you'd like to contribute, please feel free to submit a pull request. Help is always appreciated.
+
+## Support
+
+If you find this package useful and would like to support its and general development, you can contribute through one of the following payment methods. Your support helps maintain the packages and continue adding new.
+
+Support via:
+
+- [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
+
+- [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!
+
+## Code of Conduct
+
+By participating in this project, you agree to follow **[Code of Conduct](https://www.contributor-covenant.org/version/2/1/code_of_conduct/)**.
+
+## GIT
+
+### Commit
+
+- [AngularJS Git Commit Message Conventions][git-commit-angular]
+- [Karma Git Commit Msg][git-commit-karma]
+- [Conventional Commits][git-commit-conventional]
+
+### Versioning
+
+[Semantic Versioning 2.0.0][git-semver]
+
+**Given a version number MAJOR.MINOR.PATCH, increment the:**
+
+- MAJOR version when you make incompatible API changes,
+- MINOR version when you add functionality in a backwards-compatible manner, and
+- PATCH version when you make backwards-compatible bug fixes.
+
+Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format.
+
+**FAQ**
+How should I deal with revisions in the 0.y.z initial development phase?
+
+> The simplest thing to do is start your initial development release at 0.1.0 and then increment the minor version for each subsequent release.
+
+How do I know when to release 1.0.0?
+
+> If your software is being used in production, it should probably already be 1.0.0. If you have a stable API on which users have come to depend, you should be 1.0.0. If you’re worrying a lot about backwards compatibility, you should probably already be 1.0.0.
+
+## License
+
+MIT © typedly ([license][package-license])
+
+## Packages
+
+- **[@typedly/array](https://github.com/typedly/array)**: A **TypeScript** type definitions package to handle array-related operations.
+- **[@typedly/callback](https://github.com/typedly/callback)**: A **TypeScript** type definitions package for asynchronous and synchronous callback functions of various types.
+- **[@typedly/character](https://github.com/typedly/character)**: A **TypeScript** type definitions package for various character types.
+- **[@typedly/context](https://github.com/typedly/context)**: A **TypeScript** type definitions package for context data structures.
+- **[@typedly/descriptor](https://github.com/typedly/descriptor)**: A **TypeScript** type definitions package for property descriptor.
+- **[@typedly/digit](https://github.com/typedly/digit)**: A **TypeScript** type definitions package for digit types.
+- **[@typedly/letter](https://github.com/typedly/letter)**: A **TypeScript** type definitions package for handling letter types.
+- **[@typedly/object](https://github.com/typedly/object)**: A **TypeScript** type definitions package to handle object-related operations.
+- **[@typedly/payload](https://github.com/typedly/payload)**: A **TypeScript** type definitions package for payload data structures.
+- **[@typedly/property](https://github.com/typedly/property)**: A **TypeScript** type definitions package to handle object property-related operations.
+- **[@typedly/regexp](https://github.com/typedly/regexp)**: A **TypeScript** type definitions package for `RegExp`.
+- **[@typedly/symbol](https://github.com/typedly/symbol)**: A **TypeScript** type definitions package for various symbols.
+
+<!-- Funding -->
+[github-badge-sponsor]: https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&link=https://github.com/sponsors/angular-package
+[github-sponsor-link]: https://github.com/sponsors/angular-package
+[patreon-badge]: https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.vercel.app%2Fapi%3Fusername%3Dangularpackage%26type%3Dpatrons&style=flat
+[patreon-link]: https://www.patreon.com/join/angularpackage/checkout?fan_landing=true&rid=0
+
+<!-- This package: typedly  -->
+  <!-- GitHub: badges -->
+  [package-badge-issues]: https://img.shields.io/github/issues/typedly/data-traits
+  [package-badge-forks]: https://img.shields.io/github/forks/typedly/data-traits
+  [package-badge-stars]: https://img.shields.io/github/stars/typedly/data-traits
+  [package-badge-license]: https://img.shields.io/github/license/typedly/data-traits
+  <!-- GitHub: badges links -->
+  [package-issues]: https://github.com/typedly/data-traits/issues
+  [package-forks]: https://github.com/typedly/data-traits/network
+  [package-license]: https://github.com/typedly/data-traits/blob/master/LICENSE
+  [package-stars]: https://github.com/typedly/data-traits/stargazers
+<!-- This package -->
+
+<!-- Package: typedly -->
+  <!-- npm -->
+  [package-npm-badge-svg]: https://badge.fury.io/js/@typedly%2Fdata-traits.svg
+  [package-npm-badge]: https://badge.fury.io/js/@typedly%2Fdata-traits
+
+<!-- GIT -->
+[git-semver]: http://semver.org/
+
+<!-- GIT: commit -->
+[git-commit-angular]: https://gist.github.com/stephenparish/9941e89d80e2bc58a153
+[git-commit-karma]: http://karma-runner.github.io/0.10/dev/git-commit-msg.html
+[git-commit-conventional]: https://www.conventionalcommits.org/en/v1.0.0/

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@typedly/data-traits",
+  "version": "1.0.0",
+  "author": "wwwdev.io <dev@wwwdev.io>",
+  "description": "A TypeScript type definitions package for configurable data traits, providing various kinds of configurable data interfaces.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/typedly/data-traits.git"
+  },
+  "bugs": {
+    "url": "https://github.com/typedly/data-traits/issues"
+  },
+  "keywords": [
+    "@typedly",
+    "@typedly/data",
+    "@typedly/data-traits",
+    "Data Traits",
+    "Configurable Data",
+    "Adaptable Data",
+    "Comparable Data",
+    "Encryptable Data",
+    "Resettable Data",
+    "Serializable Data",
+    "Timestamped Data",
+    "Transformable Data",
+    "Validatable Data"
+  ],
+  "funding": [
+    {
+      "type": "stripe",
+      "url": "https://donate.stripe.com/dR614hfDZcJE3wAcMM"
+    },
+    {
+      "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"
+    }
+  ],
+  "sideEffects": false,
+  "typings": "types/typedly-data-traits.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/typedly-data-traits.d.ts",
+      "default": "./fesm2022/typedly-data-traits.mjs"
+    }
+  }
+}

package/types/typedly-data-traits.d.ts

@@ -0,0 +1,760 @@
+import { AsyncReturn } from '@typedly/data';
+
+/**
+ * @description The interface for adaptable data types, which can optionally use a data adapter to manage their value and behavior.
+ * @export
+ * @interface Adaptable
+ * @template [A=unknown] The adapter type, which can be `undefined`, defaults to `unknown`.
+ */
+interface Adaptable<A = unknown> {
+    /**
+     * @description The adapter of data instance, which can be `undefined` if no adapter is used.
+     * @readonly
+     * @type {?A}
+     */
+    readonly adapter?: A;
+    /**
+     * @description Checks if the data instance has an adapter.
+     * @returns {boolean} True if an adapter is present, false otherwise.
+     */
+    hasAdapter?(): boolean;
+}
+
+/**
+ * @description The interface for cacheable data types, which can be cached with an optional expiration time and invalidated or refreshed as needed.
+ * @export
+ * @interface Cacheable
+ * @template T The data type.
+ * @template {boolean} [R=false] Whether the cache operations are asynchronous.
+ */
+interface Cacheable<T, R extends boolean = false> {
+    /**
+     * @description Cache expiration time in milliseconds.
+     */
+    cacheDuration?: number;
+    /**
+     * @description Invalidates the cache.
+     * @returns {AsyncReturn<R, void>}
+     */
+    invalidateCache(): AsyncReturn<R, void>;
+    /**
+     * @description Whether the data is currently cached.
+     * @returns {boolean} True if the data is cached, false otherwise.
+     */
+    isCached(): boolean;
+    /**
+     * @description Refreshes cached data.
+     * @returns {AsyncReturn<R, T>} The refreshed data, allowing for chaining.
+     */
+    refresh(): AsyncReturn<R, T>;
+}
+
+/**
+ * @description Capability for objects that can be cleaned or cleared.
+ * @export
+ * @interface Cleanable
+ * @template {boolean} [R=false] Whether the cleanup and clear methods return a `Promise` or not.
+ */
+interface Cleanable<R extends boolean = false> {
+    /**
+     * @description Cleans up resources (event listeners, timers, subscriptions).
+     * @returns {AsyncReturn<R, void>}
+     */
+    cleanup?(): AsyncReturn<R, void>;
+    /**
+     * @description Clears the current value, resetting to empty/default state.
+     * Does not destroy the instance - it remains usable.
+     * @returns {AsyncReturn<R, this>}
+     */
+    clear(): AsyncReturn<R, this>;
+    /**
+     * @description Checks if the data is empty/cleared.
+     * @returns {boolean}
+     */
+    isEmpty(): boolean;
+}
+
+/**
+ * @description Capability for objects that can be cloned.
+ * @export
+ * @interface Cloneable
+ * @template T The options type for customizing the cloning behavior.
+ * @template {boolean} [R=false] Whether the clone method returns a `Promise` or not.
+ */
+interface Cloneable<O, R extends boolean = false> {
+    /**
+     * @description Creates a deep copy of this instance.
+     * @returns {AsyncReturn<R, this>}
+     */
+    clone(): AsyncReturn<R, this>;
+    /**
+     * @description Creates a shallow copy of this instance.
+     * @returns {AsyncReturn<R, this>}
+     */
+    shallowClone?(): AsyncReturn<R, this>;
+    /**
+     * @description Creates a deep copy with custom cloning options.
+     * @param {O} options Cloning configuration.
+     * @returns {AsyncReturn<R, this>}
+     */
+    cloneWith?(options: O): AsyncReturn<R, this>;
+}
+
+/**
+ * @description Trait for collection-like data types that can hold multiple items and provide methods for adding, deleting, and iterating over those items.
+ * @export
+ * @interface Collection
+ * @template E Element type contained in the collection.
+ * @template {boolean} [R=false] whether the methods return a `Promise` or not.
+ */
+interface Collection<E, R extends boolean = false> extends Iterable<E>, AsyncIterable<E> {
+    /**
+     * @description The number of items in the collection.
+     * @returns {number}
+     */
+    readonly size: number;
+    /**
+     * @description Adds elements to the collection.
+     * @param {...E[]} element Element of type `E` to add.
+     * @returns {AsyncReturn<R, this>} The collection instance `this`, or in `Promise`.
+     */
+    add(...element: E[]): AsyncReturn<R, this>;
+    /**
+     * @description Deletes elements from the collection.
+     * @param {...E[]} element Element of type `E` to delete.
+     * @returns {AsyncReturn<R, boolean>} `true` if every element was successfully deleted, otherwise `false`.
+     */
+    delete(...element: E[]): AsyncReturn<R, boolean>;
+    /**
+     * @description Executes a provided function once for each collection element.
+     * @param {(element: E, collection: Collection<E, R>) => void} callbackfn Function to execute for each element.
+     * @param {?*} [thisArg] Value to use as `this` when executing `callbackfn`.
+     * @returns {AsyncReturn<R, this>}
+     */
+    forEach(callbackfn: (element: E, collection: Collection<E, R>) => void, thisArg?: any): AsyncReturn<R, this>;
+    /**
+     * @description Checks if every item exists in the collection.
+     * @param {...E[]} element Element of type `E` to check for existence.
+     * @returns {AsyncReturn<R, boolean>} `true` if every element exists, otherwise `false`.
+     */
+    has(...element: E[]): AsyncReturn<R, boolean>;
+    /**
+     * @description Converts the collection to an array of elements.
+     * @returns {AsyncReturn<R, E[]>} The array of elements, or in `Promise` if `R` is `true`.
+     */
+    toArray?(): AsyncReturn<R, E[]>;
+}
+
+/**
+ * @description Comparable interface for data types that can be compared.
+ * @export
+ * @interface Comparable
+ * @template T The data type.
+ */
+interface Comparable<T> {
+    /**
+     * @description Compares this data with another.
+     * @param {T} other
+     * @returns {number} -1 if less, 0 if equal, 1 if greater
+     */
+    compare(other: T): number;
+    /**
+     * @description Checks if this data equals another.
+     * @param {T} other
+     * @returns {boolean}
+     */
+    equals(other: T): boolean;
+}
+
+/**
+ * @description Interface for data types that can be compressed and decompressed, allowing for efficient storage and transmission of data.
+ * @export
+ * @interface Compressible
+ * @template T The data type.
+ * @template [C=Uint8Array] The type of the compressed data, defaulting to `Uint8Array`.
+ * @template {boolean} [R=false] Whether the operations are asynchronous, defaulting to `false`.
+ */
+interface Compressible<T, C = Uint8Array, R extends boolean = false> {
+    /**
+     * @description Compresses the data.
+     * @returns {AsyncReturn<R, C>} The compressed data, allowing for chaining.
+     */
+    compress(): AsyncReturn<R, C>;
+    /**
+     * @description Decompresses data.
+     * @param {C} compressed The compressed data.
+     * @returns {AsyncReturn<R, T>} The decompressed data.
+     */
+    decompress(compressed: C): AsyncReturn<R, T>;
+    /**
+     * @description Gets compression ratio.
+     * @returns {number} Ratio (0-1)
+     */
+    getCompressionRatio(): number;
+}
+
+/**
+ * @description The interface for configurable data types, which can optionally have a configuration object.
+ * @export
+ * @interface Configurable
+ * @template [C=unknown] The type of the configuration object.
+ */
+interface Configurable<C = unknown> {
+    /**
+     * @description The configuration of the `Data` instance.
+     * @readonly
+     * @type {?C}
+     */
+    readonly configuration?: C;
+}
+
+/**
+ * @description Interface for data types that can be encrypted and decrypted.
+ * @export
+ * @interface Encryptable
+ * @template T The data to be encrypted/decrypted.
+ * @template [O=string] The type of the encryption key, defaulting to `string`.
+ * @template {boolean} [R=false] Whether the operations are asynchronous, defaulting to `false`.
+ */
+interface Encryptable<T, O = string, R extends boolean = false> {
+    /**
+     * @description Decrypts the data with the given key.
+     * @param {string} encrypted Encrypted data.
+     * @param {?O} options Decryption options, typically the decryption key.
+     * @returns {AsyncReturn<R, T>}
+     */
+    decrypt(encrypted: string, options?: O): AsyncReturn<R, T>;
+    /**
+     * @description Encrypts the data with the given key.
+     * @param {?O} options Encryption options, typically the encryption key.
+     * @returns {AsyncReturn<R, string>}
+     */
+    encrypt(options?: O): AsyncReturn<R, string>;
+    /**
+     * @description Whether the data is currently encrypted.
+     * @returns {boolean} True if the data is encrypted, false otherwise.
+     */
+    isEncrypted(): boolean;
+}
+
+/**
+ * @description The interface for exportable data types, which can be exported to various formats.
+ * @export
+ * @interface Exportable
+ * @template T The data type.
+ * @template {boolean} [R=false] Whether the export operations are asynchronous.
+ */
+interface Exportable<F, R extends boolean = false> {
+    /**
+     * @description Exports to custom format.
+     * @param {F} format The format to export to.
+     * @returns {AsyncReturn<R, string>}
+     */
+    export(format: F): AsyncReturn<R, string>;
+    /**
+     * @description Exports to CSV (if applicable).
+     * @returns {AsyncReturn<R, string>}
+     */
+    toCSV?(): AsyncReturn<R, string>;
+    /**
+     * @description Exports to JSON.
+     * @returns {AsyncReturn<R, string>}
+     */
+    toJSON(): AsyncReturn<R, string>;
+    /**
+     * @description Exports to XML.
+     * @returns {AsyncReturn<R, string>}
+     */
+    toXML?(): AsyncReturn<R, string>;
+}
+
+/**
+ * @description The interface for freezable data types, which can be frozen to prevent modifications and optionally unfrozen.
+ * @export
+ * @interface Freezable
+ * @template [T=any] The data type that can be frozen, used for optional checks in `isFrozen`.
+ * @template {boolean} [R=false] Whether the freeze/unfreeze operations are asynchronous.
+ */
+interface Freezable<T = any, R extends boolean = false> {
+    /**
+     * @description Freezes the data, preventing modifications.
+     * @returns {AsyncReturn<R, this>} The instance after freezing, allowing for chaining.
+     */
+    freeze(): AsyncReturn<R, this>;
+    /**
+     * @description Whether the data is frozen.
+     * @param {?T} o Optional data to check if frozen, if supported by implementation.
+     * @returns {boolean} True if the data is frozen, false otherwise.
+     */
+    isFrozen(o?: T): boolean;
+    /**
+     * @description Unfreezes the data.
+     * @returns {AsyncReturn<R, this>} The instance after unfreezing, allowing for chaining.
+     */
+    unfreeze?(): AsyncReturn<R, this>;
+}
+
+/**
+ * @description Trait for objects that have an ID or unique identifier.
+ * @export
+ * @interface Identifiable
+ * @template [ID=string] The type of the unique identifier.
+ */
+interface Identifiable<ID = string> {
+    /**
+     * @description The unique identifier of the object.
+     * @readonly
+     * @type {ID}
+     */
+    readonly id?: ID;
+    /**
+     * @description The string tag of the data instance.
+     * @readonly
+     * @type {?string}
+     */
+    readonly [Symbol.toStringTag]?: string;
+}
+
+/**
+ * @description Trait for objects that support indexing or retrieving by numeric or string index.
+ * @export
+ * @interface Indexable
+ * @template [E=any] The type of the items in indexed collection.
+ * @template [I=number | string] The type of the index, typically number for arrays or `string` for objects.
+ * @template {boolean} [R=false]
+ */
+interface Indexable<E = any, I = number | string, R extends boolean = false> {
+    /**
+     * @description Number of items.
+     * @readonly
+     * @type {number}
+     */
+    readonly length: number;
+    /**
+     * @description Retrieves an item by its index.
+     * @param {I} index The index of the item.
+     * @returns {AsyncReturn<R, E | undefined>} The item at the specified index.
+     */
+    get(index: I): AsyncReturn<R, E | undefined>;
+    /**
+     * @description Checks if an item exists at the specified index.
+     * @param {I} index The index to check.
+     * @returns {AsyncReturn<R, boolean>} True if an item exists at the index, false otherwise.
+     */
+    has(index: I): AsyncReturn<R, boolean>;
+    /**
+     * @description Retrieves all items as an array.
+     * @returns {AsyncReturn<R, E[]>} An array of all items.
+     */
+    getAll(): AsyncReturn<R, E[]>;
+    /**
+     * @description Retrieves all indices as an array.
+     * @returns {AsyncReturn<R, I[]>  } An array of all indices.
+     */
+    getIndices(): AsyncReturn<R, I[]>;
+    /**
+     * @description Retrieves all items along with their indices as an array of [index, item] pairs.
+     * @returns {AsyncReturn<R, Array<[I, E]>>} An array of [index, item] pairs.
+     */
+    entries(): AsyncReturn<R, Array<[I, E]>>;
+    /**
+     * @description Sets the value at the specified index.
+     * @param {I} index The index to set the value at.
+     * @param {E} value The value to set.
+     * @return {AsyncReturn<R, this>} The instance of the object after setting the value.
+     */
+    set(index: I, value: E): AsyncReturn<R, this>;
+    /**
+     * @description Deletes the value at the specified index.
+     * @param {I} index The index to delete the value from.
+     */
+    delete(index: I): AsyncReturn<R, this>;
+    /**
+     * @description Deletes the value at the specified indices.
+     * @param {...I[]} index The indices to delete the values from.
+     * @returns {AsyncReturn<R, this>} The instance of the object after deleting the values.
+     */
+    delete(...index: I[]): AsyncReturn<R, this>;
+}
+
+/**
+ * @description Interface for data types that can be measured in terms of size and memory usage, allowing for efficient management of resources and optimization of performance.
+ * @export
+ * @interface Measurable
+ */
+interface Measurable {
+    /**
+     * @description Checks if data exceeds size limit.
+     * @param {number} limit Size limit in bytes.
+     * @returns {boolean}
+     */
+    exceedsLimit(limit: number): boolean;
+    /**
+     * @description Gets memory usage.
+     * @returns {number} Bytes
+     */
+    getMemoryUsage(): number;
+    /**
+     * @description Gets the size in bytes.
+     * @returns {number}
+     */
+    getSize(): number;
+}
+
+/**
+ * @description The interface for mergeable data types, which can be combined with other instances of the same type using a defined strategy.
+ * @export
+ * @interface Mergeable
+ * @template T The data type.
+ * @template {boolean} [R=false] Whether the operations are asynchronous, defaulting to `false`.
+ */
+interface Mergeable<T, R extends boolean = false> {
+    /**
+     * @description Checks if can merge with another instance.
+     * @param {T} other The other data instance to check.
+     * @returns {boolean} Whether the instances can be merged.
+     */
+    canMerge(other: T): boolean;
+    /**
+     * @description Merges with another data instance.
+     * @param {T} other The other data instance to merge with.
+     * @param {(a: T, b: T) => T} strategy - Merge strategy
+     * @returns {AsyncReturn<R, this>}
+     */
+    merge(other: T, strategy?: (a: T, b: T) => T): AsyncReturn<R, this>;
+}
+
+/**
+ * @description The interface for observable data types, which allow subscribers to be notified of changes to their value.
+ * @export
+ * @interface Observable
+ * @template T The type of the value being observed.
+ * @template {boolean} [R=false] Whether the operations are asynchronous, defaulting to `false`.
+ * @template {L} [L=(value: T, previous?: T) => AsyncReturn<R, void>] The type of the listener function, defaulting to a function that takes the new value and optionally the previous value.
+ */
+interface Observable<T, R extends boolean = false, L = (value: T, previous?: T) => AsyncReturn<R, void>> {
+    /**
+     * @description Notifies all subscribers of current value.
+     * @param {T} [value] The new value to notify subscribers with, if supported by implementation. If not provided, may notify with current value or simply trigger listeners.
+     * @returns {AsyncReturn<R, void>} Resolves when all subscribers have been notified, if asynchronous. Otherwise, returns `void`.
+     */
+    notify(value?: T): AsyncReturn<R, void>;
+    /**
+     * @description Subscribes to value changes.
+     * @param {L} listener Called when value changes
+     * @returns {() => void} Unsubscribe function
+     */
+    subscribe(listener: L): () => void;
+    /**
+     * @description Unsubscribes a specific listener.
+     * @param {L} listener The listener to remove.
+     */
+    unsubscribe(listener: L): void;
+    /**
+     * @description Removes all subscribers.
+     */
+    unsubscribeAll(): void;
+}
+
+/**
+ * @description Trait for objects that support pagination.
+ * @export
+ * @interface Paginated
+ * @template [T=unknown] The type of items in the paginated collection.
+ */
+interface Paginated<T = unknown> {
+    /**
+     * @description Total number of pages.
+     * @readonly
+     * @type {number}
+     */
+    readonly pageCount: number;
+    /**
+     * @description Current page index, starting from 0.
+     * @readonly
+     * @type {number}
+     */
+    readonly pageIndex: number;
+    /**
+     * @description Number of items per page.
+     * @readonly
+     * @type {number}
+     */
+    readonly pageSize: number;
+    /**
+     * @description Returns the current page of items.
+     * @returns {T[]}
+     */
+    getPage(): T[];
+    /**
+     * @description Advances to the next page and returns its items.
+     * @returns {T[]}
+     */
+    nextPage(): T[];
+    /**
+     * @description Goes back to the previous page and returns its items.
+     * @returns {T[]}
+     */
+    previousPage(): T[];
+}
+
+/**
+ * @description Trait for objects that can be persisted and restored.
+ * @export
+ * @interface Persistable
+ * @template {boolean} [R=false] Whether the operations are asynchronous, defaulting to `false`.
+ */
+interface Persistable<R extends boolean = false> {
+    /**
+     * @description Deletes the persisted data.
+     * @returns {AsyncReturn<R, this>}
+     */
+    delete(): AsyncReturn<R, this>;
+    /**
+     * @description Restores the object from storage or database.
+     * @returns {AsyncReturn<R, this>}
+     */
+    load(): AsyncReturn<R, this>;
+    /**
+     * @description Persists the object, e.g. to storage or database.
+     * @returns {AsyncReturn<R, this>}
+     */
+    save(): AsyncReturn<R, this>;
+}
+
+/**
+ * @description Trait for objects that can be printed as a string or in a formatted way.
+ * @export
+ * @interface Printable
+ */
+interface Printable {
+    /**
+     * @description Prints the object to a string.
+     * @returns {string}
+     */
+    print(): string;
+    /**
+     * @description Optionally, pretty-prints the object.
+     * @returns {string}
+     */
+    prettyPrint?(): string;
+}
+
+/**
+ * @description Interfaces for data types that can be queried using a defined query format, allowing for flexible and efficient retrieval of information based on specific criteria.
+ * @export
+ * @interface Queryable
+ * @template T The data type.
+ * @template Q The query format (JSON query, GraphQL, predicate, etc.)
+ * @template {boolean} [R=false] Whether the operations are asynchronous, defaulting to `false`.
+ */
+interface Queryable<T, Q, R extends boolean = false> {
+    /**
+     * @description Counts items matching the query.
+     * @param {Q} query The query object, structure depends on implementation.
+     * @returns {AsyncReturn<R, number>} The count of items matching the query.
+     */
+    count?(query: Q): AsyncReturn<R, number>;
+    /**
+     * @description Filters the data (if collection-like).
+     * @param {(item: T) => boolean} predicate - The predicate function to filter items.
+     * @returns {AsyncReturn<R, T[]>} The filtered results.
+     */
+    filter?(predicate: (item: T) => boolean): AsyncReturn<R, T[]>;
+    /**
+     * @description Finds a single item that matches the query.
+     * @param {Q} query The query object, structure depends on implementation.
+     * @returns {AsyncReturn<R, T | null>} The found item or `null` if not found.
+     */
+    findOne?(query: Q): AsyncReturn<R, T | null>;
+    /**
+     * @description Queries the data.
+     * @param {Q} query - The query object, structure depends on implementation.
+     * @returns {AsyncReturn<R, T[]>} The query results.
+     */
+    query(query: Q): AsyncReturn<R, T[]>;
+}
+
+/**
+ * @description Interface for data types that can be reset to an initial value and track if they have been modified (dirty state).
+ * @export
+ * @interface Resettable
+ * @template T The type of the value that can be reset.
+ * @template {boolean} [R=false] Whether the reset operation is asynchronous.
+ */
+interface Resettable<T, R extends boolean = false> {
+    /**
+     * @description Gets the initial value.
+     * @returns {T} The initial value.
+     */
+    getInitialValue(): T;
+    /**
+     * @description Checks if data has been modified from initial state.
+     * @returns {boolean} True if modified (dirty), false if unchanged (clean).
+     */
+    isDirty(): boolean;
+    /**
+     * @description Resets to initial value.
+     * @returns {AsyncReturn<R, this>} The instance after reset, allowing for chaining.
+     */
+    reset(): AsyncReturn<R, this>;
+}
+
+/**
+ * @description Trait for objects that can revert or undo changes.
+ * @export
+ * @interface Revertible
+ * @template V The type of the version.
+ * @template {boolean} [R=false] Whether the revert operations are asynchronous.
+ */
+interface Revertible<V = unknown, R extends boolean = false> {
+    /**
+     * @description Checks if the object can be reverted.
+     * @returns {boolean} True if revert is possible, false otherwise.
+     */
+    canRevert(): boolean;
+    /**
+     * @description Reverts the object to its previous state.
+     * @param {V} [version] The version to revert to. If not provided, reverts to the most recent previous version.
+     * @returns {AsyncReturn<R, this>} The reverted instance.
+     */
+    revert(version?: V): AsyncReturn<R, this>;
+}
+
+/**
+ * @description Serializable interface for data types that can be serialized and deserialized.
+ * @export
+ * @interface Serializable
+ * @template T The type of the value to be serialized and deserialized.
+ * @template {boolean} [R=false] The async flag, indicating whether the serialization and deserialization methods are asynchronous.
+ */
+interface Serializable<T, R extends boolean = false> {
+    /**
+     * @description Serializes the data instance to a string.
+     * @returns {AsyncReturn<R, string>}
+     */
+    serialize(): AsyncReturn<R, string>;
+    /**
+     * @description Deserializes a string to a data instance.
+     * @param {string} data The string to be deserialized.
+     * @returns {AsyncReturn<R, T>}
+     */
+    deserialize(data: string): AsyncReturn<R, T>;
+}
+
+/**
+ * @description Interface representing timestamped data.
+ * @export
+ * @interface Timestamped
+ */
+interface Timestamped {
+    /**
+     * @description When the data was created.
+     * @readonly
+     */
+    readonly createdAt: Date;
+    /**
+     * @description When the data was last modified.
+     * @readonly
+     */
+    readonly updatedAt: Date;
+    /**
+     * @description When the data was last accessed.
+     * @readonly
+     */
+    readonly accessedAt?: Date;
+}
+
+/**
+ * @description Transformable interface for data types that can be transformed.
+ * @export
+ * @interface Transformable
+ * @template T The type of the value to be transformed.
+ * @template {boolean} [R=false] The async flag, indicating whether the transformation methods are asynchronous.
+ */
+interface Transformable<T, R extends boolean = false> {
+    /**
+     * @description Chains transformations with async support.
+     * @template U The transformed value type.
+     * @param {(value: T) => AsyncReturn<R, U>} fn Async transformation function.
+     * @returns {AsyncReturn<R, U>} The transformed value.
+     */
+    flatMap?<U>(fn: (value: T) => AsyncReturn<R, U>): AsyncReturn<R, U>;
+    /**
+     * @description Transforms the `Data` instance using the provided function.
+     * @template U The transformed value type.
+     * @param {(value: T) => U} fn The function to transform the `Data` instance.
+     * @returns {AsyncReturn<R, U>} The transformed `Data` instance.
+     */
+    map<U>(fn: (value: T) => U): AsyncReturn<R, U>;
+}
+
+/**
+ * @description Interface for data types that can be validated with custom rules and track validation errors.
+ * @export
+ * @interface Validatable
+ * @template T The data type.
+ * @template {boolean} [R=false] Whether the validation operations are asynchronous.
+ */
+interface Validatable<T, R extends boolean = false> {
+    /**
+     * @description Gets validation errors if any.
+     * @returns {string[]} Array of error messages
+     */
+    getErrors(): string[];
+    /**
+     * @description Checks if the current value is valid without throwing.
+     * @returns {boolean} True if valid, false otherwise.
+     */
+    isValid(): boolean;
+    /**
+     * @description Sets a custom validator function.
+     * @param {(value: T) => boolean} validator The validator function to set.
+     * @returns {AsyncReturn<R, this>} The instance after setting the validator, allowing for chaining.
+     */
+    setValidator(validator: (value: T) => boolean): AsyncReturn<R, this>;
+    /**
+     * @description Validates the current value against defined rules.
+     * @returns {AsyncReturn<R, boolean>} True if valid, false otherwise.
+     */
+    validate(): AsyncReturn<R, boolean>;
+}
+
+/**
+ * @description The interface for versionable data types, which maintain a history of changes and can revert to previous versions.
+ * @export
+ * @interface Versionable
+ * @template T The data type.
+ * @template [V=unknown] The type of the version.
+ * @template {boolean} [R=false] Whether the versioning operations are asynchronous.
+ * @extends {Revertible<V, R>}
+ */
+interface Versionable<T, V = unknown, R extends boolean = false> extends Revertible<V, R> {
+    /**
+     * @description Current version number.
+     * @readonly
+     */
+    readonly version: V;
+    /**
+     * @description Gets version history.
+     * @returns {Array<{version: V, value: T, timestamp: Date}>}
+     */
+    getHistory(): Array<{
+        version: V;
+        value: T;
+        timestamp: Date;
+    }>;
+    /**
+     * @description Reverts to a previous version.
+     * @param {V} version
+     * @returns {AsyncReturn<R, this>}
+     */
+    revert(version: V): AsyncReturn<R, this>;
+    /**
+     * @description Creates a snapshot of current state.
+     * @returns {AsyncReturn<R, T>}
+     */
+    snapshot(): AsyncReturn<R, T>;
+}
+
+export type { Adaptable, Cacheable, Cleanable, Cloneable, Collection, Comparable, Compressible, Configurable, Encryptable, Exportable, Freezable, Identifiable, Indexable, Measurable, Mergeable, Observable, Paginated, Persistable, Printable, Queryable, Resettable, Revertible, Serializable, Timestamped, Transformable, Validatable, Versionable };