\n\n \n\nA strongly-typed, decorator-driven wrapper around [Dynamoose v4](https://dynamoosejs.com/) — the DynamoDB ODM for Node.js.\n\n📚 **[Read the Documentation](https://leandroluk.github.io/dynamoose-typed)**\n\n## Why this exists\n\nDynamoose is a great library, but its TypeScript story is painfully lacking. The return types of `model()` are overloaded to the point where nothing is inferred correctly, every operation resolves to `any`, and the schema definition is a plain object with no type-safety. You end up fighting the type system instead of relying on it.\n\n`dynamoose-typed` wraps Dynamoose behind a fully-typed API that mirrors [TypeORM](https://typeorm.io/)'s `DataSource` / `Repository` / `EntityManager` pattern. Define your tables as decorated classes, let the library wire up the schema, and get proper types everywhere.\n\n## Features\n\n- Decorator-based schema definition (`@DynamoTable`, `@StringAttribute`, `@NestedAttribute`, …)\n- Typed `Repository` and `EntityManager` for all CRUD operations\n- Automatic `created_at` / `updated_at` / soft-delete (`deleted_at`) timestamps\n- GSI support via `index: true` or `index: { name, rangeKey, project }` on any attribute decorator\n- `count()` sparse-GSI optimization — two `Select: COUNT` scans instead of fetching item bodies\n- Atomic transactions via `dataSource.transaction()`\n- Live change observation via native DynamoDB Streams — `Repository.subscribe()`\n- Batch operations (`batchSave`, `batchGet`, `batchDelete`)\n- `InMemoryDataSource` for fast, zero-infrastructure unit tests\n- Optimistic locking via `@VersionAttribute` — prevents write conflicts with automatic condition checks\n- Global table name prefix/suffix — isolate environments via `DataSourceOptions.table`\n- Throughput configuration — `ON_DEMAND` or provisioned capacity via `@DynamoTable` or `DataSourceOptions.table`\n- 100% statement / branch / function coverage\n\n## Requirements\n\n- Node.js ≥ 22\n- TypeScript with `experimentalDecorators: true` and `emitDecoratorMetadata: true`\n\n## Get started\n\n```bash\npnpm add dynamoose-typed dynamoose @aws-sdk/client-dynamodb\n```\n\n### tsconfig.json\n\n```json\n{\n \"compilerOptions\": {\n \"experimentalDecorators\": true,\n \"emitDecoratorMetadata\": true,\n \"strict\": true\n }\n}\n```\n\n## Defining a table\n\n```typescript\nimport { DynamoTable, StringAttribute, NumberAttribute, CreateDateAttribute, UpdateDateAttribute, DeleteDateAttribute } from 'dynamoose-typed';\nimport crypto from 'node:crypto';\n\n@DynamoTable('users', {\n hooks: {\n beforeInsert: (item) => console.log('inserting', item),\n },\n})\nclass UserTable {\n @StringAttribute({ hashKey: true, default: crypto.randomUUID })\n id!: string;\n\n @StringAttribute({ required: true })\n name!: string;\n\n @NumberAttribute({ default: 0 })\n age!: number;\n\n @CreateDateAttribute('created_at')\n createdAt!: Date;\n\n @UpdateDateAttribute('updated_at')\n updatedAt!: Date;\n\n @DeleteDateAttribute('deleted_at')\n deletedAt!: Date | null;\n}\n```\n\n## Nested documents\n\n```typescript\nimport { DynamoDocument, StringAttribute, NestedAttribute } from 'dynamoose-typed';\nimport crypto from 'node:crypto';\n\n@DynamoDocument()\nclass AddressDocument {\n @StringAttribute({ required: true })\n street!: string;\n\n @StringAttribute({ required: true })\n city!: string;\n}\n\n@DynamoTable('orders')\nclass OrderTable {\n @StringAttribute({ hashKey: true, default: crypto.randomUUID })\n id!: string;\n\n @NestedAttribute(() => AddressDocument)\n address!: AddressDocument;\n\n @ArrayAttribute(() => String, { default: () => [] })\n tags!: string[];\n\n @SetAttribute(() => String)\n roles!: Set;\n}\n```\n\n## DataSource\n\n```typescript\nimport { DataSource, DynamoDB } from 'dynamoose-typed';\n\nconst dataSource = new DataSource({\n entities: [UserTable, OrderTable],\n client: new DynamoDB({ region: 'us-east-1' }),\n});\n\nawait dataSource.initialize();\n```\n\nFor DynamoDB Local:\n\n```typescript\nconst dataSource = new DataSource({\n entities: [UserTable],\n local: { host: 'localhost', port: 8000 },\n});\nawait dataSource.initialize();\n```\n\n### Pinging connection\n\nYou can verify the connectivity and credentials configuration at any time without accessing a specific table by calling `ping()`:\n\n```typescript\nconst isHealthy = await dataSource.ping();\n```\n\n`InMemoryDataSource` also implements this method and always returns `true` to ensure API parity in tests.\n\n## Streaming changes\n\nEnable DynamoDB Streams on a table with the `stream` option, then subscribe to live changes:\n\n```typescript\nimport { DynamoTable, StringAttribute } from 'dynamoose-typed';\n\n@DynamoTable('users', { stream: true }) // shorthand for 'NEW_AND_OLD_IMAGES'\nclass UserTable {\n @StringAttribute({ hashKey: true })\n id!: string;\n\n @StringAttribute()\n name!: string;\n}\n\nconst userRepository = dataSource.getRepository(UserTable);\n\nconst subscription = userRepository.subscribe({\n eventTypes: ['INSERT', 'MODIFY', 'REMOVE'],\n callback: async (user, meta) => {\n console.log('user changed', user.id, user.name, meta.eventName, meta.eventId);\n },\n options: {\n onError: (err) => console.error('stream error', err),\n },\n});\n\n// on application shutdown\nawait subscription.close();\n```\n\n- `INSERT` / `MODIFY` deliver the **new** item image. `REMOVE` delivers the **old** (pre-delete) item image.\n- `callback` also receives `meta`, with:\n - `eventId` — the DynamoDB Streams record's `eventID` (a synthetic id for `InMemoryRepository`). Useful for dedup/idempotency when reprocessing events.\n - `eventName` — which change triggered the event (`INSERT` / `MODIFY` / `REMOVE`), useful when subscribing to multiple event types at once.\n - `approximateCreationDateTime` — when DynamoDB applied the change.\n - `sequenceNumber` — the shard-ordered sequence number of the record.\n - `oldItem` — the item image prior to the change. Populated for `MODIFY` and `REMOVE` events if the table's stream view type supports old images (`NEW_AND_OLD_IMAGES` or `OLD_IMAGE`).\n- `repo.delete()` (soft delete) is an `UpdateItem` under the hood — it fires `MODIFY`, not `REMOVE`. Only `repo.hardDelete()` fires `REMOVE`.\n- The stream is enabled/updated on the physical table lazily, on the first `subscribe()` call — not at `DataSource.initialize()` time. This requires `dynamodb:DescribeTable` and `dynamodb:UpdateTable` IAM permissions in addition to the Streams read permissions (`dynamodb:DescribeStream`, `dynamodb:GetRecords`, `dynamodb:GetShardIterator`).\n- **DynamoDB Local (the official AWS jar) does not support Streams** — `subscribe()` needs a backend that implements the Streams API: real AWS DynamoDB, or an emulator like [LocalStack](https://www.localstack.cloud/). Against an emulator, pass a fully-configured client via `DataSourceOptions.client` (with `region`, `endpoint`, and dummy `credentials`) instead of `local: true` — `local: true` builds a client with no region/credentials, which the AWS SDK's default provider chain may fail to resolve for the Streams calls. See `.examples/streams` for a working example against LocalStack.\n- `InMemoryDataSource` / `InMemoryRepository` support the same `subscribe()` API by simulating events synchronously in-process — no AWS connection needed in tests.\n- Changing the `stream` view type on a table that already has streams enabled with a different view type is not handled automatically — AWS requires disabling and re-enabling the stream in separate calls, so you must do that manually (e.g. via the AWS console/CLI) before the next `subscribe()` call.\n\n### Retry on transient errors\n\n`subscribe()` is resilient to transient failures during stream bootstrap:\n\n- **`ensureStreamEnabled`** retries `describeTable` with exponential backoff (up to 15 attempts, 500ms–15s) when the table does not yet exist (`ResourceNotFoundException`). This is always active — no configuration needed.\n- **`StreamPoller`** retries `describeStream` and `getShardIterator` with backoff when the stream reports itself as not yet ACTIVE. This is also always active.\n\nAdditionally, you can opt into retrying the **entire stream bootstrap** (including stream enabling and poller creation) when the table is still provisioning:\n\n```typescript\nconst subscription = userRepository.subscribe({\n eventTypes: ['INSERT', 'MODIFY', 'REMOVE'],\n callback: async (user, meta) => {\n console.log('user changed', user.id, meta.eventName);\n },\n options: {\n onError: (err) => console.error('stream error', err),\n retry: {\n maxRetries: 30, // try for ~2 minutes (default: 15)\n baseDelayMs: 1000, // first retry after 1s\n maxDelayMs: 10000, // never wait more than 10s between retries\n },\n },\n});\n```\n\nWhen `retry` is set, the bootstrap is retried on `ResourceNotFoundException` with exponential backoff. If all retries are exhausted, the final error is forwarded to `onError`. You can still call `subscription.close()` to cancel a pending retry.\n\n## Table name prefix/suffix\n\nWhen multiple environments share a single DynamoDB account, you can isolate them using a table name prefix or suffix rather than separate regions:\n\n```typescript\n// production: @DynamoTable('users') → 'prod_users'\nconst dataSource = new DataSource({\n entities: [UserTable, OrderTable],\n client: new DynamoDB({ region: 'us-east-1' }),\n table: { prefix: 'prod_' },\n});\n\n// staging: @DynamoTable('users') → 'staging_users'\nconst stagingDs = new DataSource({\n entities: [UserTable],\n client: new DynamoDB({ region: 'us-east-1' }),\n table: { prefix: 'staging_' },\n});\n\n// both prefix and suffix: @DynamoTable('users') → 'prod_users_v2'\nconst ds = new DataSource({\n entities: [UserTable],\n client: new DynamoDB({ region: 'us-east-1' }),\n table: { prefix: 'prod_', suffix: '_v2' },\n});\n```\n\nWorks with `InMemoryDataSource` too — useful for verifying naming conventions in tests:\n\n```typescript\nconst ds = new InMemoryDataSource({\n entities: [UserTable],\n table: { prefix: 'prod_' },\n});\n```\n\n## Throughput configuration\n\nSet the DynamoDB billing mode per table or globally:\n\n```typescript\n// per-table — ON_DEMAND (pay-per-request)\n@DynamoTable('users', { throughput: 'ON_DEMAND' })\nclass UserTable { ... }\n\n// per-table — provisioned with separate read/write\n@DynamoTable('orders', { throughput: { read: 10, write: 5 } })\nclass OrderTable { ... }\n\n// global default for all tables (overridden per-table if set)\nconst dataSource = new DataSource({\n entities: [UserTable, OrderTable],\n client: new DynamoDB({ region: 'us-east-1' }),\n table: { throughput: 'ON_DEMAND' },\n});\n```\n\nPer-table `throughput` takes precedence over the global default. When neither is set, Dynamoose's default applies (`read: 5, write: 5`).\n\n## Repository\n\n```typescript\nconst userRepository = dataSource.getRepository(UserTable);\n\n// create (no persistence)\nconst newUser = userRepository.create({ name: 'Alice', age: 30 });\n\n// save\nconst savedUser = await userRepository.save(newUser);\n\n// find by key\nconst foundUser = await userRepository.findOneBy({ id: savedUser.id });\n\n// find by key — throws if not found or soft-deleted\nconst user = await userRepository.findOneByOrFail({ id: '123' });\n\n// include soft-deleted items\nconst deletedUser = await userRepository.findOneBy({ id: '123' }, { withDeleted: true });\n\n// query by hash key\nconst { items, count, lastKey } = await userRepository.find('alice-partition', {\n limit: 20,\n consistent: true,\n startAt: lastKey,\n});\n\n// query by hash key + sort key condition (requires rangeKey on table)\nconst { items: recent } = await userRepository.find('user-1', {\n sortKey: { between: ['2024-01', '2024-12'] },\n});\nconst { items: after } = await userRepository.find('user-1', {\n sortKey: { beginsWith: '2024-' },\n});\n\n// full-table scan\nconst { items: allUsers } = await userRepository.scan({ withDeleted: false });\n\n// query by GSI (requires index: true on the attribute)\nconst { items: byEmail } = await userRepository.findByIndex('email', 'alice@example.com');\n\n// count\nconst total = await userRepository.count();\n\n// soft-delete (sets deleted_at) — falls back to hardDelete if no @DeleteDateAttribute\nawait userRepository.delete({ id: savedUser.id });\n\n// hard delete\nawait userRepository.hardDelete({ id: savedUser.id });\n\n// restore soft-deleted item\nawait userRepository.restore({ id: savedUser.id });\n\n// batch operations\nawait userRepository.batchSave([user1, user2, user3]);\nawait userRepository.batchDelete([{ id: '1' }, { id: '2' }]);\nconst users = await userRepository.batchGet([{ id: '1' }, { id: '2' }]);\n```\n\n## EntityManager\n\nAccess via `dataSource.manager` to work with multiple entities without creating a repo for each:\n\n```typescript\nconst manager = dataSource.manager;\n\nconst user = await manager.findOneByOrFail(UserTable, { id: '1' });\nconst order = await manager.findOneByOrFail(OrderTable, { id: 'o1' });\n\nawait manager.save(user);\nawait manager.delete(OrderTable, { id: 'o1' });\n```\n\n## Transactions\n\nReads inside the callback execute immediately. Writes are collected and flushed atomically via `dynamoose.transaction()` when the callback resolves. If the callback throws, no writes are flushed.\n\n```typescript\nawait dataSource.transaction(async (tx) => {\n const user = await tx.findOneByOrFail(UserTable, { id: '1' });\n user.name = 'Updated';\n await tx.save(user); // enqueued\n\n await tx.delete(OrderTable, { id: 'o1' }); // enqueued\n});\n// both writes committed atomically here\n```\n\n> DynamoDB limits: max 100 items per transaction, same-region only.\n\n## Optimistic locking\n\n`@VersionAttribute` adds an integer version counter to a table. On `update()`, if the `changes` object includes the version field, the library automatically:\n\n1. Adds a DynamoDB condition: `version = expectedVersion`\n2. Increments the stored value to `expectedVersion + 1`\n\nIf another process modified the item between your read and write, DynamoDB rejects the update and `OptimisticLockError` is thrown.\n\n```typescript\nimport { DynamoTable, StringAttribute, VersionAttribute, OptimisticLockError } from 'dynamoose-typed';\n\n@DynamoTable('products')\nclass ProductTable {\n @StringAttribute({ hashKey: true })\n id!: string;\n\n @StringAttribute()\n name!: string;\n\n @VersionAttribute()\n version!: number; // starts at 0, auto-incremented on each update\n}\n\nconst repo = dataSource.getRepository(ProductTable);\n\n// save() on a versioned table uses put-if-not-exists semantics\nconst product = await repo.save({ id: 'p1', name: 'Widget', version: 0 });\n\n// update() with version: optimistic lock applied automatically\ntry {\n await repo.update({ id: 'p1' }, { name: 'Widget v2', version: 0 });\n // if version in DB is still 0 → succeeds, DB version becomes 1\n} catch (err) {\n if (err instanceof OptimisticLockError) {\n // another process wrote between your read and this update\n }\n}\n```\n\nOmitting the version field from `changes` skips the condition check entirely, making the update unconditional.\n\n## Attribute decorators reference\n\n| Decorator | DynamoDB type | Notes |\n| ------------------------------ | ------------- | ---------------------------------------------------------------------------------------------------------------------|\n| `@StringAttribute` | S | Supports `hashKey`, `rangeKey`, `minLength`, `maxLength`, `trim`, `lowercase`, `uppercase` |\n| `@NumberAttribute` | N | Supports `min`, `max` |\n| `@BooleanAttribute` | BOOL | |\n| `@DateAttribute` | S / N | `format: 'epoch'` (default) or `'iso'`; `ttl: true` stores epoch **seconds** with auto transforms |\n| `@CreateDateAttribute` | S / N | Set once on insert, never updated; `format: 'epoch'` (default) or `'iso'` |\n| `@UpdateDateAttribute` | S / N | Updated on every save/update; `format: 'epoch'` (default) or `'iso'` |\n| `@DeleteDateAttribute` | S / N | Set by `delete()`, cleared by `restore()`; `index: true` enables sparse-GSI `count()` optimization |\n| `@VersionAttribute` | N | Starts at `0`; `update()` with version field applies optimistic-lock condition and auto-increments |\n| `@NestedAttribute(() => Doc)` | M | Doc must be decorated with `@DynamoDocument` |\n| `@ArrayAttribute(() => Type)` | L | Primitives or `@DynamoDocument` instances |\n| `@SetAttribute(() => Type)` | SS / NS | Must be a `Set` or `Set` |\n| `@Attribute(options)` | any | Raw Dynamoose attribute passthrough |\n\nAll decorators accept an optional first argument `alias` (string) to map a TypeScript property name to a different DynamoDB attribute name:\n\n```typescript\n@StringAttribute('full_name', { required: true })\nfullName!: string;\n// stored as \"full_name\" in DynamoDB, accessed as .fullName in code\n```\n\nAll decorators also accept `index: true` to create a DynamoDB GSI on that attribute (default name: `${attributeName}GlobalIndex`), or `index: { name, rangeKey, project }` for a custom-named / composite GSI. Both forms are queryable through `repo.findByIndex(...)`:\n\n```typescript\n@StringAttribute({ index: true })\nemail!: string; // creates \"emailGlobalIndex\" GSI\n\n@StringAttribute('parent_id', { index: { name: 'parentIdIndex', rangeKey: 'createdAt' } })\nuserIdOwner!: string; // creates \"parentIdIndex\" GSI\n```\n\n## GSI indexes\n\nPass `index: true` on any attribute decorator to create a DynamoDB GSI:\n\n```typescript\n@DynamoTable('users')\nclass UserTable {\n @StringAttribute({ hashKey: true })\n id!: string;\n\n @StringAttribute({ index: true }) // GSI: \"emailGlobalIndex\"\n email!: string;\n\n // sparse GSI on soft-delete — enables count() optimization\n @DeleteDateAttribute('deleted_at', { index: true })\n deletedAt!: Date | null;\n}\n```\n\nUse `repo.findByIndex(propertyKey, value)` to query any GSI. The library maps the TypeScript property key to the DynamoDB attribute name (alias-aware) and resolves the index name in this order:\n\n1. `options.indexName` — explicit override\n2. the name declared on the attribute's `index` option — `index: { name: 'X' }` → `X`, `index: true` → `${attrName}GlobalIndex`\n3. `${attrName}GlobalIndex` — fallback\n\n```typescript\nconst { items } = await userRepository.findByIndex('email', 'alice@example.com');\nconst { items: active } = await userRepository.findByIndex('isActive', true, { limit: 50 });\n\n// custom-named GSI: @StringAttribute('parent_id', { index: { name: 'parentIdIndex' } })\nconst { items: owned } = await installationRepository.findByIndex('userIdOwner', userId);\n\n// or force a specific physical index\nconst { items } = await installationRepository.findByIndex('userIdOwner', userId, {\n indexName: 'parentIdIndex',\n});\n```\n\nWhen `index: true` is set on `@DeleteDateAttribute`, `repo.count()` uses a two-`Select: COUNT` strategy instead of scanning item bodies:\n\n```typescript\n// 2× Select:COUNT — total minus GSI count (only soft-deleted items appear in the sparse index)\nconst activeCount = await repo.count();\n\n// plain Select:COUNT — no soft-delete filter needed\nconst totalCount = await repo.count({ withDeleted: true });\n```\n\n| Condition | Strategy | Item bodies |\n| ------------------------------------- | -------------------------------- | ----------- |\n| `withDeleted: true` or no soft-delete | `Select: COUNT` | No |\n| Soft-delete + GSI (`index: true`) | 2× `Select: COUNT` (total − GSI) | No |\n| Soft-delete, no GSI | Full scan + client-side filter | Yes |\n\n## Hooks\n\nHooks run before/after each write operation. Declare them on `@DynamoTable`:\n\n```typescript\n@DynamoTable('users', {\n hooks: {\n beforeInsert: async (item) => { /* validate, enrich */ },\n afterInsert: async (item) => { /* emit event */ },\n beforeUpdate: async (item) => { /* audit log */ },\n afterUpdate: async (item) => { /* cache invalidation */ },\n beforeDelete: async (item) => { /* cascade */ },\n afterDelete: async (item) => { /* cleanup */ },\n },\n})\nclass UserTable { ... }\n```\n\n## Testing with InMemoryDataSource\n\nNo DynamoDB connection, no AWS credentials needed. Drop it in wherever you use `DataSource`:\n\n```typescript\nimport { InMemoryDataSource } from 'dynamoose-typed/testing';\n\ndescribe('UserService', () => {\n let dataSource: InMemoryDataSource;\n\n beforeEach(() => {\n dataSource = new InMemoryDataSource({ entities: [UserTable] });\n });\n\n it('creates and retrieves a user', async () => {\n const repo = dataSource.getRepository(UserTable);\n await repo.save({ id: '1', name: 'Alice', age: 30 });\n const user = await repo.findOneBy({ id: '1' });\n expect(user?.name).toBe('Alice');\n });\n});\n```\n\n`InMemoryDataSource` exposes the same `getRepository`, `manager`, and `transaction` surface as the real `DataSource`, so your service code under test doesn't change at all.\n\n## Tips\n\n**Attribute aliases keep DynamoDB attribute names decoupled from TypeScript property names.** Use snake_case attribute names in DynamoDB and camelCase properties in code by passing an alias string as the first argument to any attribute decorator.\n\n**Soft deletes are automatic when `@DeleteDateAttribute` is present.** Calling `repo.delete()` sets the column; `repo.restore()` clears it. All queries and scans filter out soft-deleted rows by default — pass `{ withDeleted: true }` to include them. Add `index: true` to enable the sparse-GSI `count()` optimization and avoid full scans.\n\n**`repo.delete()` falls back to a hard delete when the entity has no `@DeleteDateAttribute`.** No soft-delete column → `delete()` permanently removes the item, identical to calling `hardDelete()` directly. Tables that need both behaviors should declare `@DeleteDateAttribute` and call `hardDelete()` explicitly when a permanent removal is intended.\n\n**`getRepository` lazy-initializes the DataSource** if you haven't called `initialize()` yet. This is useful for lightweight scripts that don't need an explicit boot sequence.\n\n**Timestamp storage format defaults to `epoch` (milliseconds as Number).** Pass `{ format: 'iso' }` to store as ISO-8601 strings instead. The `Date` native storage type is no longer supported.\n\n**DynamoDB transactions have a hard limit of 100 items.** If your callback enqueues more than 100 writes, DynamoDB will reject the flush. Split large transactions into smaller chunks.\n\n**`InMemoryDataSource.clear()` resets all in-memory data.** Call it in `beforeEach` to keep tests isolated:\n\n```typescript\nbeforeEach(() => dataSource.clear());\n```\n\n## Utility functions\n\n### `serializeDynamoTableItem(instance)`\n\nConverts a `@DynamoTable` class instance to a plain object using DynamoDB attribute names (respecting aliases) and serializing `Date` values to their storage format. Useful for migration scripts, event processors, or any code that needs to convert TypeScript objects to DynamoDB format without a running `DataSource`.\n\n```typescript\nimport { serializeDynamoTableItem } from '@leandroluk/dynamoose-typed';\n\n@DynamoTable('users')\nclass UserTable {\n @StringAttribute({ hashKey: true }) id!: string;\n @StringAttribute('full_name') name!: string;\n @CreateDateAttribute('created_at') createdAt!: Date;\n}\n\nconst user = new UserTable();\nuser.id = '1';\nuser.name = 'Alice';\nuser.createdAt = new Date('2024-01-01T00:00:00.000Z');\n\nserializeDynamoTableItem(user);\n// → { id: '1', full_name: 'Alice', created_at: 1704067200000 }\n```\n\n### `parseDynamoTableItem(entityClass, raw)`\n\nConverts a raw DynamoDB attribute-named object back into a typed `@DynamoTable` class instance, reversing alias mappings and deserializing stored date values back to `Date` objects.\n\n```typescript\nimport { parseDynamoTableItem } from '@leandroluk/dynamoose-typed';\n\nparseDynamoTableItem(UserTable, { id: '1', full_name: 'Alice', created_at: 1704067200000 });\n// → UserTable { id: '1', name: 'Alice', createdAt: Date(2024-01-01) }\n```\n\nBoth functions handle nested `@DynamoDocument` objects and arrays of documents recursively. Unknown fields (not declared in the schema) are passed through as-is in both directions.\n\n## Contributors\n\nThanks goes to these wonderful people\n\n\n\n\n
\n\n\n\n\n\n\nThis project follows the [all-contributors](https://allcontributors.org) specification. Contributions of any kind welcome!\n\n## Support\n\nIf you find this project useful, please consider supporting its development:\n\n\n","readmeFilename":"README.md"}
![\"Dynamoose](\"docs/assets/banner.png\")
\n![\"Diego](\"https://avatars.githubusercontent.com/u/57909002?v=4?s=100\")
![\"Leandro](\"https://avatars.githubusercontent.com/u/8602982?v=4?s=100\")
![\"Vitor](\"https://avatars.githubusercontent.com/u/104171028?v=4?s=100\")
![\"Buy](\"https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png\")
\n","readmeFilename":"README.md"}![\"NPM](\"https://img.shields.io/npm/v/@leandroluk/dynamoose-typed.svg\")
\n ![\"License\"](\"https://img.shields.io/npm/l/@leandroluk/dynamoose-typed.svg\")
\n ![\"Downloads\"](\"https://img.shields.io/npm/dw/@leandroluk/dynamoose-typed.svg\")
\n ![\"CI](\"https://img.shields.io/github/actions/workflow/status/leandroluk/dynamoose-typed/ci.yml?branch=master\")
\n ![\"Coverage](\"https://img.shields.io/badge/coverage-100%25-brightgreen.svg\"){kind=icon}
\n ![\"All](\"https://img.shields.io/badge/all_contributors-3-orange.svg\"){kind=icon}
\n ![\"Buy](\"https://img.shields.io/badge/Buy%20Me%20a%20Coffee-ffdd00?style=flat&logo=buy-me-a-coffee&logoColor=black\"){kind=icon}
\n