@ftschopp/dynatable-core 1.0.0 → 1.2.0

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+# @ftschopp/dynatable-core [1.2.0](https://github.com/ftschopp/dynatable/compare/@ftschopp/dynatable-core@1.1.0...@ftschopp/dynatable-core@1.2.0) (2026-03-20)
+
+
+### Features
+
+* support nested objects and arrays schema ([c06e43e](https://github.com/ftschopp/dynatable/commit/c06e43e6b425bae09f127d2f767b5c8c62dd1142))
+
+# @ftschopp/dynatable-core [1.1.0](https://github.com/ftschopp/dynatable/compare/@ftschopp/dynatable-core@1.0.0...@ftschopp/dynatable-core@1.1.0) (2026-01-20)
+
+
+### Bug Fixes
+
+* improve types ([efdf362](https://github.com/ftschopp/dynatable/commit/efdf362cefa94f5b6cba653b3a0cc8d017da6966))
+
+
+### Features
+
+* improve types ([3a87c5c](https://github.com/ftschopp/dynatable/commit/3a87c5c37565f92d8c4a4790396eefa57cd9a5c5))
+
 # @ftschopp/dynatable-core 1.0.0 (2026-01-10)
 
 

package/README.md

@@ -1,17 +1,543 @@
 # @ftschopp/dynatable-core
 
-A type-safe, functional programming library for AWS DynamoDB with Single Table Design support.
+A type-safe, functional programming library for AWS DynamoDB with Single Table Design support. Built with TypeScript and designed to make DynamoDB development elegant and productive.
+
+## Features
+
+- 🔐 **Type-Safe** - Full TypeScript support with end-to-end type inference
+- 🎯 **Single Table Design** - Built-in support for DynamoDB best practices
+- 🔄 **Functional API** - Chainable, composable operations with immutable builders
+- ⚡️ **Auto-generated IDs** - ULID/UUID generation for unique identifiers
+- 🕒 **Automatic Timestamps** - Auto-manage `createdAt` and `updatedAt`
+- 🔒 **Transactions** - Atomic operations with `TransactWrite` and `TransactGet`
+- 📦 **Batch Operations** - Efficient `BatchGet` and `BatchWrite` operations
+- 🎨 **Query Builder** - Intuitive, type-safe API for complex queries
+- ✅ **Validation** - Built-in Zod schema validation
+- 🧪 **Testable** - Easy to mock and test with AWS SDK client mock support
 
 ## Installation
 
 ```bash
 npm install @ftschopp/dynatable-core
+# or
+yarn add @ftschopp/dynatable-core
+# or
+pnpm add @ftschopp/dynatable-core
+```
+
+## Quick Start
+
+```typescript
+import { Table } from '@ftschopp/dynatable-core';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+
+// Define your schema
+const schema = {
+  format: 'dynatable:1.0.0',
+  version: '1.0.0',
+  indexes: {
+    primary: { hash: 'PK', sort: 'SK' },
+  },
+  models: {
+    User: {
+      key: {
+        PK: { type: String, value: 'USER#${username}' },
+        SK: { type: String, value: 'USER#${username}' },
+      },
+      attributes: {
+        username: { type: String, required: true },
+        name: { type: String, required: true },
+        email: { type: String, required: true },
+      },
+    },
+  },
+  params: {
+    timestamps: true,
+    isoDates: true,
+  },
+} as const;
+
+// Create DynamoDB client
+const ddbClient = new DynamoDBClient({ region: 'us-east-1' });
+const client = DynamoDBDocumentClient.from(ddbClient);
+
+// Create table instance
+const table = new Table({
+  name: 'MyTable',
+  client,
+  schema,
+});
+
+// Use it!
+async function example() {
+  // Create
+  const user = await table.entities.User.put({
+    username: 'alice',
+    name: 'Alice Smith',
+    email: 'alice@example.com',
+  }).execute();
+
+  // Read
+  const retrieved = await table.entities.User.get({
+    username: 'alice',
+  }).execute();
+
+  // Update
+  await table.entities.User.update({ username: 'alice' })
+    .set('name', 'Alice Johnson')
+    .execute();
+
+  // Query
+  const users = await table.entities.User.query()
+    .where((attr, op) => op.eq(attr.username, 'alice'))
+    .execute();
+
+  // Delete
+  await table.entities.User.delete({ username: 'alice' }).execute();
+}
+```
+
+## Core Concepts
+
+### Schema Definition
+
+Define your data models with full type inference:
+
+```typescript
+const schema = {
+  format: 'dynatable:1.0.0',
+  version: '1.0.0',
+
+  indexes: {
+    primary: { hash: 'PK', sort: 'SK' },
+    gsi1: { hash: 'GSI1PK', sort: 'GSI1SK' },
+  },
+
+  models: {
+    User: {
+      key: {
+        PK: { type: String, value: 'USER#${username}' },
+        SK: { type: String, value: 'USER#${username}' },
+      },
+      index: {
+        GSI1PK: { type: String, value: 'USER' },
+        GSI1SK: { type: String, value: 'USER#${username}' },
+      },
+      attributes: {
+        username: { type: String, required: true },
+        name: { type: String, required: true },
+        email: { type: String },
+        userId: { type: String, generate: 'ulid' },
+        followerCount: { type: Number, default: 0 },
+        // Nested object with typed schema
+        address: {
+          type: Object,
+          schema: {
+            street: { type: String },
+            city: { type: String, required: true },
+            country: { type: String, required: true },
+          },
+        },
+        // Typed array with item schema
+        tags: {
+          type: Array,
+          default: [],
+          items: { type: String },
+        },
+      },
+    },
+  },
+
+  params: {
+    timestamps: true,      // Auto createdAt/updatedAt
+    isoDates: true,        // Use ISO 8601 dates
+    cleanInternalKeys: false, // Hide PK/SK from results
+  },
+} as const;
+```
+
+### Nested Objects and Arrays
+
+Attributes support typed nested schemas for full TypeScript inference:
+
+```typescript
+Story: {
+  attributes: {
+    // Typed array of objects
+    frames: {
+      type: Array,
+      default: [],
+      items: {
+        type: Object,
+        schema: {
+          url: { type: String, required: true },
+          duration: { type: Number },
+          mediaType: { type: String },
+        },
+      },
+    },
+    // Nested object with a typed schema
+    location: {
+      type: Object,
+      schema: {
+        city: { type: String },
+        country: { type: String },
+        lat: { type: Number },
+        lng: { type: Number },
+      },
+    },
+  },
+}
+```
+
+Use `ArrayItem<T>` to extract item types from array attributes:
+
+```typescript
+import type { InferModelFromSchema, ArrayItem } from '@ftschopp/dynatable-core';
+
+type StoryEntity = InferModelFromSchema<typeof schema, 'Story'>;
+type StoryFrame = ArrayItem<StoryEntity['frames']>;
+// → { url: string; duration?: number; mediaType?: string }
+```
+
+### Type Inference
+
+Extract types from your schema:
+
+```typescript
+import type {
+  InferModel,
+  InferInput,
+  InferKeyInput,
+  InferModelFromSchema,
+  InferInputFromSchema,
+  ArrayItem,
+} from '@ftschopp/dynatable-core';
+
+// Preferred: infer from the full schema (timestamps included automatically)
+type User = InferModelFromSchema<typeof schema, 'User'>;
+// { username: string; name: string; email?: string; userId: string; followerCount: number; createdAt: string; updatedAt: string }
+
+type UserInput = InferInputFromSchema<typeof schema, 'User'>;
+// { username: string; name: string; email?: string; followerCount?: number }
+
+// Full model type (deprecated — use InferModelFromSchema)
+type UserLegacy = InferModel<typeof schema.models.User>;
+
+// Input type (deprecated — use InferInputFromSchema)
+type UserInputLegacy = InferInput<typeof schema.models.User>;
+
+// Key input type (only key template variables)
+type UserKey = InferKeyInput<typeof schema.models.User>;
+// { username: string }
+
+// Extract item type from an array attribute
+type StoryEntity = InferModelFromSchema<typeof schema, 'Story'>;
+type StoryFrame = ArrayItem<StoryEntity['frames']>;
+// → { url: string; duration?: number; mediaType?: string }
+```
+
+### Builder Operations
+
+All operations use the immutable builder pattern:
+
+```typescript
+// GET - Retrieve item
+const user = await table.entities.User.get({ username: 'alice' })
+  .select(['name', 'email'])
+  .consistentRead()
+  .execute();
+
+// PUT - Insert/replace item
+await table.entities.User.put({
+  username: 'alice',
+  name: 'Alice',
+  email: 'alice@example.com',
+})
+  .ifNotExists()
+  .returning('ALL_OLD')
+  .execute();
+
+// UPDATE - Modify attributes
+await table.entities.User.update({ username: 'alice' })
+  .set('name', 'Alice Johnson')
+  .add('followerCount', 1)
+  .remove('email')
+  .returning('ALL_NEW')
+  .where((attr, op) => op.gt(attr.followerCount, 0))
+  .execute();
+
+// DELETE - Remove item
+await table.entities.User.delete({ username: 'alice' })
+  .returning('ALL_OLD')
+  .where((attr, op) => op.exists(attr.email))
+  .execute();
+
+// QUERY - Query with conditions
+const photos = await table.entities.Photo.query()
+  .where((attr, op) =>
+    op.and(
+      op.eq(attr.username, 'alice'),
+      op.gt(attr.likesCount, 10)
+    )
+  )
+  .limit(20)
+  .scanIndexForward(false)
+  .execute();
+
+// SCAN - Full table scan with filter
+const activeUsers = await table.entities.User.scan()
+  .where((attr, op) => op.gt(attr.followerCount, 1000))
+  .limit(50)
+  .execute();
+
+// BATCH GET - Retrieve multiple items
+const users = await table.entities.User.batchGet([
+  { username: 'alice' },
+  { username: 'bob' },
+  { username: 'charlie' },
+]).execute();
+
+// BATCH WRITE - Write multiple items
+await table.entities.User.batchWrite([
+  { username: 'alice', name: 'Alice', email: 'alice@example.com' },
+  { username: 'bob', name: 'Bob', email: 'bob@example.com' },
+]).execute();
+```
+
+### Transactions
+
+Atomic operations across multiple items:
+
+```typescript
+// TransactWrite - Atomic writes
+await table.transactWrite()
+  .addPut(
+    table.entities.Like.put({
+      photoId: 'photo1',
+      likingUsername: 'alice',
+    })
+      .ifNotExists()
+      .dbParams()
+  )
+  .addUpdate(
+    table.entities.Photo.update({ photoId: 'photo1' })
+      .add('likesCount', 1)
+      .dbParams()
+  )
+  .execute();
+
+// TransactGet - Atomic reads
+const result = await table.transactGet()
+  .addGet(table.entities.User.get({ username: 'alice' }).dbParams())
+  .addGet(table.entities.Photo.get({ photoId: 'photo1' }).dbParams())
+  .execute();
+
+const [user, photo] = result.items;
+```
+
+## Available Operators
+
+Build complex conditions with type-safe operators:
+
+### Comparison
+- `eq(attr, value)` - Equals
+- `ne(attr, value)` - Not equals
+- `lt(attr, value)` - Less than
+- `lte(attr, value)` - Less than or equal
+- `gt(attr, value)` - Greater than
+- `gte(attr, value)` - Greater than or equal
+- `between(attr, low, high)` - Between values
+
+### String
+- `beginsWith(attr, prefix)` - Begins with prefix
+- `contains(attr, value)` - Contains value (strings, sets, lists)
+
+### Existence
+- `exists(attr)` - Attribute exists
+- `notExists(attr)` - Attribute doesn't exist
+
+### Advanced
+- `attributeType(attr, type)` - Check attribute type ('S', 'N', 'M', 'L', etc.)
+- `in(attr, values[])` - Value in array
+- `size(attr)` - Get size, returns object with `.eq()`, `.gt()`, etc.
+
+### Logical
+- `and(...conditions)` - Combine with AND
+- `or(...conditions)` - Combine with OR
+- `not(condition)` - Negate condition
+
+### Examples
+
+```typescript
+// Exists check
+await table.entities.User.update({ username: 'alice' })
+  .set('email', 'alice@example.com')
+  .where((attr, op) => op.notExists(attr.email))
+  .execute();
+
+// Contains
+const users = await table.entities.User.query()
+  .where((attr, op) =>
+    op.and(
+      op.eq(attr.username, 'alice'),
+      op.contains(attr.tags, 'premium')
+    )
+  )
+  .execute();
+
+// IN operator
+const activeUsers = await table.entities.User.scan()
+  .where((attr, op) => op.in(attr.status, ['active', 'pending']))
+  .execute();
+
+// Size function
+const posts = await table.entities.Post.query()
+  .where((attr, op) =>
+    op.and(
+      op.eq(attr.userId, 'alice'),
+      op.size(attr.tags).gte(3)
+    )
+  )
+  .execute();
+
+// Complex nested conditions
+await table.entities.Photo.query()
+  .where((attr, op) =>
+    op.and(
+      op.eq(attr.username, 'alice'),
+      op.or(
+        op.gt(attr.likesCount, 100),
+        op.and(
+          op.gt(attr.commentCount, 50),
+          op.exists(attr.featured)
+        )
+      )
+    )
+  )
+  .execute();
+```
+
+## DynamoDB Logger
+
+Debug your DynamoDB operations:
+
+```typescript
+import { createDynamoDBLogger } from '@ftschopp/dynatable-core';
+
+const logger = createDynamoDBLogger({
+  enabled: true,
+  logParams: true,
+  logResponse: false,
+});
+
+const table = new Table({
+  name: 'MyTable',
+  client,
+  schema,
+  logger, // Attach logger
+});
+
+// All operations now logged to console
 ```
 
+## Pagination
+
+Built-in pagination support:
+
+```typescript
+// Execute with pagination
+const page1 = await table.entities.Post.query()
+  .where((attr, op) => op.eq(attr.userId, 'alice'))
+  .limit(20)
+  .executeWithPagination();
+
+// Get next page
+if (page1.lastEvaluatedKey) {
+  const page2 = await table.entities.Post.query()
+    .where((attr, op) => op.eq(attr.userId, 'alice'))
+    .startFrom(page1.lastEvaluatedKey)
+    .limit(20)
+    .executeWithPagination();
+}
+```
+
+## API Reference
+
+### Core Exports
+
+```typescript
+export {
+  Table,                           // Main Table class
+  type SchemaDefinition,           // Schema type
+  type ModelDefinition,            // Model type
+  type AttributeDefinition,        // Union of all attribute types
+  type ScalarAttributeDefinition,  // String/Number/Boolean/Date attribute
+  type ObjectAttributeDefinition,  // Nested object attribute with schema
+  type ArrayAttributeDefinition,   // Typed array attribute with items
+  type PrimaryKeyDefinition,       // PK + SK key definition
+  type KeyDefinition,              // Single key definition
+  type IndexDefinition,            // Index (hash + optional sort)
+  type IndexesDefinition,          // All table indexes
+  type SchemaParams,               // Global schema params
+  type InferModel,                 // Infer model type (deprecated)
+  type InferInput,                 // Infer input type (deprecated)
+  type InferKeyInput,              // Infer key type
+  type InferModelFromSchema,       // Infer from full schema (preferred)
+  type InferInputFromSchema,       // Infer input from full schema (preferred)
+  type TimestampFields,            // createdAt/updatedAt fields type
+  type ArrayItem,                  // Extract item type from array attribute
+  createDynamoDBLogger,            // Logger factory
+  type DynamoDBLogger,             // Logger type
+  type DynamoDBLoggerConfig,       // Logger config
+};
+```
+
+### Builder Types
+
+Each builder type is exported for advanced use cases:
+
+- `GetBuilder`, `PutBuilder`, `UpdateBuilder`, `DeleteBuilder`
+- `QueryBuilder`, `ScanBuilder`
+- `BatchGetBuilder`, `BatchWriteBuilder`
+- `TransactWriteBuilder`, `TransactGetBuilder`
+- `Condition`, `OpBuilder`, `AttrBuilder`, `SizeRef`
+
+## Requirements
+
+- Node.js >= 18
+- TypeScript >= 5.0 (recommended)
+- AWS SDK v3 (`@aws-sdk/client-dynamodb`, `@aws-sdk/lib-dynamodb`)
+
+## Dependencies
+
+- `@aws-sdk/client-dynamodb` ^3.965.0
+- `@aws-sdk/lib-dynamodb` ^3.965.0
+- `zod` ^4.3.5 - Runtime validation
+- `ulid` ^3.0.2 - ULID generation
+- `ramda` ^0.32.0 - Functional utilities
+
 ## Documentation
 
-See the [main repository](https://github.com/ftschopp/dynatable) for full documentation and examples.
+For complete documentation, examples, and guides, visit the [main repository](https://github.com/ftschopp/dynatable).
+
+## Testing
+
+The library includes comprehensive test coverage with Jest:
+
+```bash
+npm test
+```
 
 ## License
 
 MIT
+
+## Contributing
+
+Contributions are welcome! Please see the [main repository](https://github.com/ftschopp/dynatable) for contribution guidelines.
+
+## Related Packages
+
+- [@ftschopp/dynatable-migrations](https://www.npmjs.com/package/@ftschopp/dynatable-migrations) - Database migration tool for schema evolution

package/dist/builders/delete/types.d.ts

@@ -1,11 +1,16 @@
+import type { DeleteCommandInput } from '@aws-sdk/lib-dynamodb';
 import { OperationBuilder } from '../shared';
 /**
  * Builder interface for DynamoDB DeleteItem operations
  */
-export interface DeleteBuilder<Model> extends OperationBuilder<Model> {
+export interface DeleteBuilder<Model> extends Omit<OperationBuilder<Model>, 'dbParams'> {
     /**
      * Configures what values should be returned after the delete operation
      */
     returning(mode: 'NONE' | 'ALL_OLD'): DeleteBuilder<Model>;
+    /**
+     * Converts the builder state to DynamoDB DeleteItem parameters
+     */
+    dbParams(): DeleteCommandInput;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/builders/delete/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/builders/delete/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IACnE;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;CAC3D"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/builders/delete/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,KAAK,CAAE,SAAQ,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IACrF;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IAE1D;;OAEG;IACH,QAAQ,IAAI,kBAAkB,CAAC;CAChC"}

package/dist/builders/get/types.d.ts

@@ -1,9 +1,10 @@
+import type { GetCommandInput } from '@aws-sdk/lib-dynamodb';
 import { ExecutableBuilder } from '../shared';
 /**
  * Builder for DynamoDB GetItem operations.
  * Supports projection, consistent read, and inspection of the final parameters.
  */
-export interface GetBuilder<KeyInput, Model> extends ExecutableBuilder<Model | undefined> {
+export interface GetBuilder<KeyInput, Model> extends Omit<ExecutableBuilder<Model | undefined>, 'dbParams'> {
     /**
      * Adds a projection expression to only return specific attributes.
      * Returns a new immutable builder.
@@ -24,5 +25,9 @@ export interface GetBuilder<KeyInput, Model> extends ExecutableBuilder<Model | u
      * - NONE: No consumed capacity data returned (default)
      */
     returnConsumedCapacity(mode: 'INDEXES' | 'TOTAL' | 'NONE'): GetBuilder<KeyInput, Model>;
+    /**
+     * Converts the builder state to DynamoDB GetItem parameters
+     */
+    dbParams(): GetCommandInput;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/builders/get/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/builders/get/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C;;;GAGG;AACH,MAAM,WAAW,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAE,SAAQ,iBAAiB,CAAC,KAAK,GAAG,SAAS,CAAC;IACvF;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,GAAG,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAE5D;;;OAGG;IACH,cAAc,IAAI,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAE9C;;;;;;;;OAQG;IACH,sBAAsB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;CACzF"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/builders/get/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C;;;GAGG;AACH,MAAM,WAAW,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAE,SAAQ,IAAI,CAAC,iBAAiB,CAAC,KAAK,GAAG,SAAS,CAAC,EAAE,UAAU,CAAC;IACzG;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,GAAG,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAE5D;;;OAGG;IACH,cAAc,IAAI,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAE9C;;;;;;;;OAQG;IACH,sBAAsB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAExF;;OAEG;IACH,QAAQ,IAAI,eAAe,CAAC;CAC7B"}

package/dist/builders/put/types.d.ts

@@ -1,8 +1,9 @@
+import type { PutCommandInput } from '@aws-sdk/lib-dynamodb';
 import { OperationBuilder } from '../shared';
 /**
  * Builder interface for DynamoDB PutItem operations
  */
-export interface PutBuilder<Model> extends OperationBuilder<Model> {
+export interface PutBuilder<Model> extends Omit<OperationBuilder<Model>, 'dbParams'> {
     /**
      * Adds a condition that the item must not exist (checks pk and sk)
      */
@@ -13,5 +14,9 @@ export interface PutBuilder<Model> extends OperationBuilder<Model> {
      * - ALL_OLD: Returns the item as it was before being replaced (if it existed)
      */
     returning(mode: 'NONE' | 'ALL_OLD'): PutBuilder<Model>;
+    /**
+     * Converts the builder state to DynamoDB PutItem parameters
+     */
+    dbParams(): PutCommandInput;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/builders/put/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/builders/put/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,KAAK,CAAE,SAAQ,gBAAgB,CAAC,KAAK,CAAC;IAChE;;OAEG;IACH,WAAW,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;IAEjC;;;;OAIG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;CACxD"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/builders/put/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,KAAK,CAAE,SAAQ,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAClF;;OAEG;IACH,WAAW,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;IAEjC;;;;OAIG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;IAEvD;;OAEG;IACH,QAAQ,IAAI,eAAe,CAAC;CAC7B"}

package/dist/builders/query/create-query-builder.d.ts

@@ -5,5 +5,5 @@ import { DynamoDBLogger } from '../../utils/dynamodb-logger';
 /**
  * Creates a QueryBuilder for a table
  */
-export declare function createQueryBuilder<Model, M extends ModelDefinition = any>(tableName: string, client: DynamoDBClient, model?: M, logger?: DynamoDBLogger): QueryBuilder<Model, M>;
+export declare function createQueryBuilder<Model>(tableName: string, client: DynamoDBClient, model?: ModelDefinition, logger?: DynamoDBLogger): QueryBuilder<Model>;
 //# sourceMappingURL=create-query-builder.d.ts.map

package/dist/builders/query/create-query-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-query-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/query/create-query-builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAK1D,OAAO,EAAE,YAAY,EAA8B,MAAM,SAAS,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAmT7D;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,CAAC,SAAS,eAAe,GAAG,GAAG,EACvE,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,cAAc,EACtB,KAAK,CAAC,EAAE,CAAC,EACT,MAAM,CAAC,EAAE,cAAc,GACtB,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC,CA4BxB"}
+{"version":3,"file":"create-query-builder.d.ts","sourceRoot":"","sources":["../../../src/builders/query/create-query-builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAK1D,OAAO,EAAE,YAAY,EAA8B,MAAM,SAAS,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAiT7D;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EACtC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,cAAc,EACtB,KAAK,CAAC,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,cAAc,GACtB,YAAY,CAAC,KAAK,CAAC,CA4BrB"}