bun-query-builder 0.1.9 → 0.1.11

package/dist/drivers/dynamodb.d.ts

@@ -0,0 +1,338 @@
+/**
+ * Create a new DynamoDB driver instance
+ */
+export declare function createDynamoDBDriver(config: DynamoDBConfig): DynamoDBDriver;
+/**
+ * DynamoDB Driver for bun-query-builder
+ *
+ * This driver supports DynamoDB's unique data model including:
+ * - Single table design patterns
+ * - Partition key (PK) and sort key (SK) based access
+ * - Global Secondary Indexes (GSI) and Local Secondary Indexes (LSI)
+ * - DynamoDB-specific operations (Query, Scan, GetItem, PutItem, etc.)
+ */
+/**
+ * DynamoDB key schema definition
+ */
+export declare interface DynamoDBKeySchema {
+  partitionKey: string
+  sortKey?: string
+}
+/**
+ * DynamoDB attribute definition for table/index creation
+ */
+export declare interface DynamoDBAttributeDefinition {
+  name: string
+  type: 'S' | 'N' | 'B'
+}
+/**
+ * Global Secondary Index definition
+ */
+export declare interface DynamoDBGlobalSecondaryIndex {
+  indexName: string
+  keySchema: DynamoDBKeySchema
+  projection: {
+    type: 'ALL' | 'KEYS_ONLY' | 'INCLUDE'
+    nonKeyAttributes?: string[]
+  }
+  provisionedThroughput?: {
+    readCapacityUnits: number
+    writeCapacityUnits: number
+  }
+}
+/**
+ * Local Secondary Index definition
+ */
+export declare interface DynamoDBLocalSecondaryIndex {
+  indexName: string
+  sortKey: string
+  projection: {
+    type: 'ALL' | 'KEYS_ONLY' | 'INCLUDE'
+    nonKeyAttributes?: string[]
+  }
+}
+/**
+ * DynamoDB table definition for single table design
+ */
+export declare interface DynamoDBTableDefinition {
+  tableName: string
+  keySchema: DynamoDBKeySchema
+  attributeDefinitions: DynamoDBAttributeDefinition[]
+  globalSecondaryIndexes?: DynamoDBGlobalSecondaryIndex[]
+  localSecondaryIndexes?: DynamoDBLocalSecondaryIndex[]
+  billingMode?: 'PROVISIONED' | 'PAY_PER_REQUEST'
+  provisionedThroughput?: {
+    readCapacityUnits: number
+    writeCapacityUnits: number
+  }
+  ttlAttribute?: string
+  streamSpecification?: {
+    enabled: boolean
+    viewType?: 'KEYS_ONLY' | 'NEW_IMAGE' | 'OLD_IMAGE' | 'NEW_AND_OLD_IMAGES'
+  }
+}
+/**
+ * Single table design entity mapping
+ * Maps model entities to PK/SK patterns
+ */
+export declare interface SingleTableEntityMapping {
+  entityType: string
+  pkPattern: string
+  skPattern: string
+  gsiMappings?: {
+    indexName: string
+    pkPattern: string
+    skPattern?: string
+  }[]
+  attributes?: Record<string, DynamoDBAttributeType>
+}
+/**
+ * DynamoDB filter condition for Query/Scan operations
+ */
+export declare interface DynamoDBCondition {
+  attribute: string
+  operator: DynamoDBComparisonOperator | 'contains' | 'attribute_exists' | 'attribute_not_exists' | 'attribute_type' | 'IN'
+  value?: any
+  values?: any[]
+}
+/**
+ * DynamoDB Query parameters
+ */
+export declare interface DynamoDBQueryParams {
+  tableName: string
+  indexName?: string
+  keyConditions: DynamoDBCondition[]
+  filterConditions?: DynamoDBCondition[]
+  projectionAttributes?: string[]
+  limit?: number
+  scanIndexForward?: boolean
+  exclusiveStartKey?: Record<string, any>
+  consistentRead?: boolean
+}
+/**
+ * DynamoDB Scan parameters
+ */
+export declare interface DynamoDBScanParams {
+  tableName: string
+  indexName?: string
+  filterConditions?: DynamoDBCondition[]
+  projectionAttributes?: string[]
+  limit?: number
+  exclusiveStartKey?: Record<string, any>
+  segment?: number
+  totalSegments?: number
+  consistentRead?: boolean
+}
+/**
+ * DynamoDB GetItem parameters
+ */
+export declare interface DynamoDBGetItemParams {
+  tableName: string
+  key: Record<string, any>
+  projectionAttributes?: string[]
+  consistentRead?: boolean
+}
+/**
+ * DynamoDB PutItem parameters
+ */
+export declare interface DynamoDBPutItemParams {
+  tableName: string
+  item: Record<string, any>
+  conditionExpression?: string
+  returnValues?: 'NONE' | 'ALL_OLD'
+}
+/**
+ * DynamoDB UpdateItem parameters
+ */
+export declare interface DynamoDBUpdateItemParams {
+  tableName: string
+  key: Record<string, any>
+  updateExpressions: {
+    set?: Record<string, any>
+    remove?: string[]
+    add?: Record<string, any>
+    delete?: Record<string, any>
+  }
+  conditionExpression?: string
+  returnValues?: 'NONE' | 'ALL_OLD' | 'UPDATED_OLD' | 'ALL_NEW' | 'UPDATED_NEW'
+}
+/**
+ * DynamoDB DeleteItem parameters
+ */
+export declare interface DynamoDBDeleteItemParams {
+  tableName: string
+  key: Record<string, any>
+  conditionExpression?: string
+  returnValues?: 'NONE' | 'ALL_OLD'
+}
+/**
+ * DynamoDB BatchGetItem parameters
+ */
+export declare interface DynamoDBBatchGetItemParams {
+  requestItems: {
+    [tableName: string]: {
+      keys: Record<string, any>[]
+      projectionAttributes?: string[]
+      consistentRead?: boolean
+    }
+  }
+}
+/**
+ * DynamoDB BatchWriteItem parameters
+ */
+export declare interface DynamoDBBatchWriteItemParams {
+  requestItems: {
+    [tableName: string]: (
+      | { putRequest: { item: Record<string, any> } }
+      | { deleteRequest: { key: Record<string, any> } }
+    )[]
+  }
+}
+/**
+ * DynamoDB TransactWriteItems parameters
+ */
+export declare interface DynamoDBTransactWriteParams {
+  transactItems: (
+    | { put: DynamoDBPutItemParams }
+    | { update: DynamoDBUpdateItemParams }
+    | { delete: DynamoDBDeleteItemParams }
+    | { conditionCheck: { tableName: string, key: Record<string, any>, conditionExpression: string } }
+  )[]
+  clientRequestToken?: string
+}
+/**
+ * DynamoDB Driver Interface
+ *
+ * Unlike SQL drivers, DynamoDB operations are API-based rather than SQL-based.
+ * This interface provides methods to build DynamoDB API request parameters.
+ */
+export declare interface DynamoDBDriver {
+  createTable: (definition: DynamoDBTableDefinition) => DynamoDBTableDefinition
+  deleteTable: (tableName: string) => { tableName: string }
+  registerEntity: (mapping: SingleTableEntityMapping) => void
+  getEntityMapping: (entityType: string) => SingleTableEntityMapping | undefined
+  buildPrimaryKey: (entityType: string, values: Record<string, any>) => { pk: string, sk: string }
+  parseEntityFromItem: (item: Record<string, any>) => { entityType: string, data: Record<string, any> } | null
+  buildQueryParams: (params: Partial<DynamoDBQueryParams>) => DynamoDBQueryParams
+  buildScanParams: (params: Partial<DynamoDBScanParams>) => DynamoDBScanParams
+  buildGetItemParams: (params: Partial<DynamoDBGetItemParams>) => DynamoDBGetItemParams
+  buildPutItemParams: (params: Partial<DynamoDBPutItemParams>) => DynamoDBPutItemParams
+  buildUpdateItemParams: (params: Partial<DynamoDBUpdateItemParams>) => DynamoDBUpdateItemParams
+  buildDeleteItemParams: (params: Partial<DynamoDBDeleteItemParams>) => DynamoDBDeleteItemParams
+  buildBatchGetItemParams: (params: Partial<DynamoDBBatchGetItemParams>) => DynamoDBBatchGetItemParams
+  buildBatchWriteItemParams: (params: Partial<DynamoDBBatchWriteItemParams>) => DynamoDBBatchWriteItemParams
+  buildTransactWriteParams: (params: Partial<DynamoDBTransactWriteParams>) => DynamoDBTransactWriteParams
+  buildKeyConditionExpression: (conditions: DynamoDBCondition[]) => {
+    expression: string
+    expressionAttributeNames: Record<string, string>
+    expressionAttributeValues: Record<string, any>
+  }
+  buildFilterExpression: (conditions: DynamoDBCondition[]) => {
+    expression: string
+    expressionAttributeNames: Record<string, string>
+    expressionAttributeValues: Record<string, any>
+  }
+  buildUpdateExpression: (updates: DynamoDBUpdateItemParams['updateExpressions']) => {
+    expression: string
+    expressionAttributeNames: Record<string, string>
+    expressionAttributeValues: Record<string, any>
+  }
+  buildProjectionExpression: (attributes: string[]) => {
+    expression: string
+    expressionAttributeNames: Record<string, string>
+  }
+  marshall: (item: Record<string, any>) => Record<string, any>
+  unmarshall: (item: Record<string, any>) => Record<string, any>
+}
+/**
+ * Single table design configuration
+ */
+export declare interface SingleTableConfig {
+  enabled: boolean
+  pkAttribute?: string
+  skAttribute?: string
+  entityTypeAttribute?: string
+  keyDelimiter?: string
+}
+/**
+ * DynamoDB configuration options
+ */
+export declare interface DynamoDBConfig {
+  region: string
+  endpoint?: string
+  credentials?: {
+    accessKeyId: string
+    secretAccessKey: string
+    sessionToken?: string
+  }
+  tableName?: string
+  entityMappings?: SingleTableEntityMapping[]
+  defaultBillingMode?: 'PROVISIONED' | 'PAY_PER_REQUEST'
+  singleTable?: SingleTableConfig
+}
+/**
+ * DynamoDB attribute type mapping
+ */
+export type DynamoDBAttributeType = 'S' | 'N' | 'B' | 'SS' | 'NS' | 'BS' | 'M' | 'L' | 'BOOL' | 'NULL'
+/**
+ * DynamoDB query condition operators
+ */
+export type DynamoDBComparisonOperator = | '='
+  | '<'
+  | '<='
+  | '>'
+  | '>='
+  | 'BETWEEN'
+  | 'begins_with'
+/**
+ * DynamoDB Driver Implementation
+ */
+export declare class DynamoDBDriverImpl implements DynamoDBDriver {
+  private config: DynamoDBConfig;
+  private entityMappings: Map<string, SingleTableEntityMapping>;
+  constructor(config: DynamoDBConfig);
+  createTable(definition: DynamoDBTableDefinition): DynamoDBTableDefinition;
+  deleteTable(tableName: string): { tableName: string };
+  registerEntity(mapping: SingleTableEntityMapping): void;
+  getEntityMapping(entityType: string): SingleTableEntityMapping | undefined;
+  buildPrimaryKey(entityType: string, values: Record<string, any>): { pk: string, sk: string };
+  parseEntityFromItem(item: Record<string, any>): { entityType: string, data: Record<string, any> } | null;
+  buildQueryParams(params: Partial<DynamoDBQueryParams>): DynamoDBQueryParams;
+  buildScanParams(params: Partial<DynamoDBScanParams>): DynamoDBScanParams;
+  buildGetItemParams(params: Partial<DynamoDBGetItemParams>): DynamoDBGetItemParams;
+  buildPutItemParams(params: Partial<DynamoDBPutItemParams>): DynamoDBPutItemParams;
+  buildUpdateItemParams(params: Partial<DynamoDBUpdateItemParams>): DynamoDBUpdateItemParams;
+  buildDeleteItemParams(params: Partial<DynamoDBDeleteItemParams>): DynamoDBDeleteItemParams;
+  buildBatchGetItemParams(params: Partial<DynamoDBBatchGetItemParams>): DynamoDBBatchGetItemParams;
+  buildBatchWriteItemParams(params: Partial<DynamoDBBatchWriteItemParams>): DynamoDBBatchWriteItemParams;
+  buildTransactWriteParams(params: Partial<DynamoDBTransactWriteParams>): DynamoDBTransactWriteParams;
+  buildKeyConditionExpression(conditions: DynamoDBCondition[]): {
+    expression: string
+    expressionAttributeNames: Record<string, string>
+    expressionAttributeValues: Record<string, any>
+  };
+  buildFilterExpression(conditions: DynamoDBCondition[]): {
+    expression: string
+    expressionAttributeNames: Record<string, string>
+    expressionAttributeValues: Record<string, any>
+  };
+  buildUpdateExpression(updates: DynamoDBUpdateItemParams['updateExpressions']): {
+    expression: string
+    expressionAttributeNames: Record<string, string>
+    expressionAttributeValues: Record<string, any>
+  };
+  buildProjectionExpression(attributes: string[]): {
+    expression: string
+    expressionAttributeNames: Record<string, string>
+  };
+  marshall(item: Record<string, any>): Record<string, any>;
+  unmarshall(item: Record<string, any>): Record<string, any>;
+  private interpolatePattern(pattern: string, values: Record<string, any>): string;
+  private buildExpression(conditions: DynamoDBCondition[], joiner: 'AND' | 'OR'): {
+    expression: string
+    expressionAttributeNames: Record<string, string>
+    expressionAttributeValues: Record<string, any>
+  };
+  private marshallValue(value: any): any;
+  private unmarshallValue(value: any): any;
+}

package/dist/drivers/index.d.ts

@@ -4,7 +4,33 @@ import { SQLiteDriver } from './sqlite';
 import type { DialectDriver } from './postgres';
 import type { SupportedDialect } from '../types';
 export type { DialectDriver } from './postgres';
+export type {
+  DynamoDBAttributeDefinition,
+  DynamoDBAttributeType,
+  DynamoDBBatchGetItemParams,
+  DynamoDBBatchWriteItemParams,
+  DynamoDBComparisonOperator,
+  DynamoDBCondition,
+  DynamoDBConfig,
+  DynamoDBDeleteItemParams,
+  DynamoDBDriver,
+  DynamoDBGetItemParams,
+  DynamoDBGlobalSecondaryIndex,
+  DynamoDBKeySchema,
+  DynamoDBLocalSecondaryIndex,
+  DynamoDBPutItemParams,
+  DynamoDBQueryParams,
+  DynamoDBScanParams,
+  DynamoDBTableDefinition,
+  DynamoDBTransactWriteParams,
+  DynamoDBUpdateItemParams,
+  SingleTableEntityMapping,
+} from './dynamodb';
 export declare function getDialectDriver(dialect: SupportedDialect): DialectDriver;
 export { MySQLDriver } from './mysql';
 export { PostgresDriver } from './postgres';
-export { SQLiteDriver } from './sqlite';
+export { SQLiteDriver } from './sqlite';
+export {
+  createDynamoDBDriver,
+  DynamoDBDriverImpl,
+} from './dynamodb';

package/dist/dynamodb/client.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Create a native DynamoDB client
+ */
+export declare function createClient(config: DynamoDBClientConfig): DynamoDBClient;
+/**
+ * Native DynamoDB HTTP Client
+ *
+ * Zero-dependency DynamoDB client using native fetch and AWS Signature V4.
+ * Implements all core DynamoDB operations without requiring @aws-sdk.
+ *
+ * @example
+ * ```typescript
+ * const client = new DynamoDBClient({
+ *   region: 'us-east-1',
+ *   credentials: {
+ *     accessKeyId: 'AKIA...',
+ *     secretAccessKey: '...',
+ *   },
+ * })
+ *
+ * const result = await client.query({
+ *   TableName: 'MyTable',
+ *   KeyConditionExpression: 'pk = :pk',
+ *   ExpressionAttributeValues: { ':pk': { S: 'USER#123' } },
+ * })
+ * ```
+ */
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface DynamoDBCredentials {
+  accessKeyId: string
+  secretAccessKey: string
+  sessionToken?: string
+}
+export declare interface DynamoDBClientConfig {
+  region: string
+  endpoint?: string
+  credentials?: DynamoDBCredentials
+}
+export declare interface DynamoDBQueryInput {
+  TableName: string
+  IndexName?: string
+  KeyConditionExpression?: string
+  FilterExpression?: string
+  ProjectionExpression?: string
+  ExpressionAttributeNames?: Record<string, string>
+  ExpressionAttributeValues?: Record<string, any>
+  Limit?: number
+  ScanIndexForward?: boolean
+  ConsistentRead?: boolean
+  ExclusiveStartKey?: Record<string, any>
+  Select?: 'ALL_ATTRIBUTES' | 'ALL_PROJECTED_ATTRIBUTES' | 'SPECIFIC_ATTRIBUTES' | 'COUNT'
+}
+export declare interface DynamoDBScanInput {
+  TableName: string
+  IndexName?: string
+  FilterExpression?: string
+  ProjectionExpression?: string
+  ExpressionAttributeNames?: Record<string, string>
+  ExpressionAttributeValues?: Record<string, any>
+  Limit?: number
+  ConsistentRead?: boolean
+  ExclusiveStartKey?: Record<string, any>
+  Segment?: number
+  TotalSegments?: number
+  Select?: 'ALL_ATTRIBUTES' | 'ALL_PROJECTED_ATTRIBUTES' | 'SPECIFIC_ATTRIBUTES' | 'COUNT'
+}
+export declare interface DynamoDBGetItemInput {
+  TableName: string
+  Key: Record<string, any>
+  ProjectionExpression?: string
+  ExpressionAttributeNames?: Record<string, string>
+  ConsistentRead?: boolean
+}
+export declare interface DynamoDBPutItemInput {
+  TableName: string
+  Item: Record<string, any>
+  ConditionExpression?: string
+  ExpressionAttributeNames?: Record<string, string>
+  ExpressionAttributeValues?: Record<string, any>
+  ReturnValues?: 'NONE' | 'ALL_OLD'
+}
+export declare interface DynamoDBUpdateItemInput {
+  TableName: string
+  Key: Record<string, any>
+  UpdateExpression?: string
+  ConditionExpression?: string
+  ExpressionAttributeNames?: Record<string, string>
+  ExpressionAttributeValues?: Record<string, any>
+  ReturnValues?: 'NONE' | 'ALL_OLD' | 'UPDATED_OLD' | 'ALL_NEW' | 'UPDATED_NEW'
+}
+export declare interface DynamoDBDeleteItemInput {
+  TableName: string
+  Key: Record<string, any>
+  ConditionExpression?: string
+  ExpressionAttributeNames?: Record<string, string>
+  ExpressionAttributeValues?: Record<string, any>
+  ReturnValues?: 'NONE' | 'ALL_OLD'
+}
+export declare interface DynamoDBBatchGetItemInput {
+  RequestItems: {
+    [tableName: string]: {
+      Keys: Record<string, any>[]
+      ProjectionExpression?: string
+      ExpressionAttributeNames?: Record<string, string>
+      ConsistentRead?: boolean
+    }
+  }
+}
+export declare interface DynamoDBBatchWriteItemInput {
+  RequestItems: {
+    [tableName: string]: (
+      | { PutRequest: { Item: Record<string, any> } }
+      | { DeleteRequest: { Key: Record<string, any> } }
+    )[]
+  }
+}
+export declare interface DynamoDBTransactWriteItemsInput {
+  TransactItems: (
+    | { Put: { TableName: string, Item: Record<string, any>, ConditionExpression?: string, ExpressionAttributeNames?: Record<string, string>, ExpressionAttributeValues?: Record<string, any> } }
+    | { Update: { TableName: string, Key: Record<string, any>, UpdateExpression: string, ConditionExpression?: string, ExpressionAttributeNames?: Record<string, string>, ExpressionAttributeValues?: Record<string, any> } }
+    | { Delete: { TableName: string, Key: Record<string, any>, ConditionExpression?: string, ExpressionAttributeNames?: Record<string, string>, ExpressionAttributeValues?: Record<string, any> } }
+    | { ConditionCheck: { TableName: string, Key: Record<string, any>, ConditionExpression: string, ExpressionAttributeNames?: Record<string, string>, ExpressionAttributeValues?: Record<string, any> } }
+  )[]
+  ClientRequestToken?: string
+}
+export declare interface DynamoDBQueryOutput {
+  Items?: Record<string, any>[]
+  Count?: number
+  ScannedCount?: number
+  LastEvaluatedKey?: Record<string, any>
+  ConsumedCapacity?: any
+}
+export declare interface DynamoDBGetItemOutput {
+  Item?: Record<string, any>
+  ConsumedCapacity?: any
+}
+export declare interface DynamoDBPutItemOutput {
+  Attributes?: Record<string, any>
+  ConsumedCapacity?: any
+}
+export declare interface DynamoDBUpdateItemOutput {
+  Attributes?: Record<string, any>
+  ConsumedCapacity?: any
+}
+export declare interface DynamoDBDeleteItemOutput {
+  Attributes?: Record<string, any>
+  ConsumedCapacity?: any
+}
+/**
+ * Native DynamoDB HTTP Client
+ *
+ * Uses AWS Signature V4 and native fetch for zero-dependency DynamoDB access.
+ */
+export declare class DynamoDBClient {
+  private config: DynamoDBClientConfig;
+  private endpoint: string;
+  private credentials: DynamoDBCredentials;
+  constructor(config: DynamoDBClientConfig);
+  private execute(operation: string, input: any): Promise<any>;
+  query(input: DynamoDBQueryInput): Promise<DynamoDBQueryOutput>;
+  scan(input: DynamoDBScanInput): Promise<DynamoDBQueryOutput>;
+  getItem(input: DynamoDBGetItemInput): Promise<DynamoDBGetItemOutput>;
+  putItem(input: DynamoDBPutItemInput): Promise<DynamoDBPutItemOutput>;
+  updateItem(input: DynamoDBUpdateItemInput): Promise<DynamoDBUpdateItemOutput>;
+  deleteItem(input: DynamoDBDeleteItemInput): Promise<DynamoDBDeleteItemOutput>;
+  batchGetItem(input: DynamoDBBatchGetItemInput): Promise<{ Responses?: Record<string, Record<string, any>[]>, UnprocessedKeys?: any }>;
+  batchWriteItem(input: DynamoDBBatchWriteItemInput): Promise<{ UnprocessedItems?: any }>;
+  transactWriteItems(input: DynamoDBTransactWriteItemsInput): Promise<{}>;
+  describeTable(tableName: string): Promise<any>;
+  createTable(input: any): Promise<any>;
+  deleteTable(tableName: string): Promise<any>;
+  listTables(input?: { ExclusiveStartTableName?: string, Limit?: number }): Promise<{ TableNames: string[], LastEvaluatedTableName?: string }>;
+  updateTable(input: any): Promise<any>;
+  updateTimeToLive(input: any): Promise<any>;
+  describeTimeToLive(tableName: string): Promise<any>;
+}

package/dist/dynamodb/index.d.ts

@@ -0,0 +1,156 @@
+import type { DynamoDBConfig, DynamoDBDriver, SingleTableEntityMapping,  } from '../drivers/dynamodb';
+export type {
+  DynamoDBConfig,
+  DynamoDBDriver,
+  SingleTableEntityMapping,
+} from '../drivers/dynamodb';
+export type { DynamoDBClientConfig, DynamoDBCredentials } from './client';
+export type { ModelConfig, ModelQueryBuilder } from './model';
+export type { MigrationDriverConfig, MigrationResult } from './migration-driver';
+export type {
+  DynamoDBMigrationPlan,
+  DynamoDBMigrationOperation,
+  DynamoDBMigrationOperationType,
+  DynamoDBMigrationState,
+  DynamoDBModelSchema,
+  DynamoDBGSIDefinition,
+  DynamoDBLSIDefinition,
+} from './migrations';
+/**
+ * Create a new DynamoDB client instance
+ */
+export declare function createDynamo(): DynamoClient;
+/**
+ * DynamoDB client singleton
+ */
+export declare const dynamo: DynamoClient;
+/**
+ * DynamoDB connection configuration
+ */
+export declare interface DynamoConnectionConfig {
+  region: string
+  table: string
+  endpoint?: string
+  credentials?: {
+    accessKeyId: string
+    secretAccessKey: string
+    sessionToken?: string
+  }
+  pkAttribute?: string
+  skAttribute?: string
+  entityTypeAttribute?: string
+  keyDelimiter?: string
+}
+/**
+ * Sort key builder for fluent API
+ */
+export declare interface SortKeyBuilder {
+  equals(value: string): EntityQueryBuilder
+  beginsWith(prefix: string): EntityQueryBuilder
+  between(start: string, end: string): EntityQueryBuilder
+  lt(value: string): EntityQueryBuilder
+  lte(value: string): EntityQueryBuilder
+  gt(value: string): EntityQueryBuilder
+  gte(value: string): EntityQueryBuilder
+}
+/**
+ * Batch write operation
+ */
+export declare interface BatchWriteOperation {
+  put?: { entity: string, item: Record<string, any> }
+  delete?: { entity: string, pk: string, sk: string }
+}
+/**
+ * Transact write operation
+ */
+export declare interface TransactWriteOperation {
+  put?: { entity: string, item: Record<string, any>, condition?: string }
+  update?: { entity: string, pk: string, sk?: string, set?: Record<string, any>, add?: Record<string, number>, remove?: string[] }
+  delete?: { entity: string, pk: string, sk: string, condition?: string }
+  conditionCheck?: { entity: string, pk: string, sk: string, condition: string }
+}
+/**
+ * DynamoDB query result
+ */
+export declare interface DynamoDBQueryResult<T = any> {
+  items: T[]
+  count: number
+  scannedCount?: number
+  lastKey?: Record<string, any>
+}
+/**
+ * Entity-centric query builder for DynamoDB
+ */
+export declare class EntityQueryBuilder<T = any> {
+  private driver: DynamoDBDriver;
+  private client: any;
+  private tableName: string;
+  private pkAttribute: string;
+  private skAttribute: string;
+  private entityTypeAttr: string;
+  private delimiter: string;
+  private _entityType?: string;
+  private _pkValue?: string;
+  private _skCondition?: { type: 'eq' | 'begins_with' | 'between' | 'lt' | 'lte' | 'gt' | 'gte', value: string, value2?: string };
+  private _indexName?: string;
+  private _projectionAttrs: string[];
+  private _filterConditions: Array<{ attribute: string, operator: string, value?: any, values?: any[] }>;
+  private _limitValue?: number;
+  private _scanForward: boolean;
+  private _consistentRead: boolean;
+  private _startKey?: Record<string, any>;
+  constructor(driver: DynamoDBDriver, client: any, tableName: string, config: { pkAttribute: string, skAttribute: string, entityTypeAttribute: string, keyDelimiter: string });
+  entity(entityType: string): this;
+  pk(value: string): this;
+  index(indexName: string): this;
+  project(attributes: string[]): this;
+  filter(attribute: string, operator: string, value?: any): this;
+  where(attribute: string, value: any): this;
+  whereIn(attribute: string, values: any[]): this;
+  limit(count: number): this;
+  asc(): this;
+  desc(): this;
+  consistent(): this;
+  startFrom(key: Record<string, any>): this;
+  toRequest(): Record<string, any>;
+  get(): Promise<T[]>;
+  first(): Promise<T | undefined>;
+  getAll(): Promise<T[]>;
+  count(): Promise<number>;
+}
+/**
+ * DynamoDB client with entity-centric API
+ */
+declare class DynamoClient {
+  private driver?: DynamoDBDriver;
+  private client?: any;
+  private tableName: string;
+  private pkAttribute: string;
+  private skAttribute: string;
+  private entityTypeAttr: string;
+  private delimiter: string;
+  private entityMappings: Map<string, SingleTableEntityMapping>;
+  connection(config: DynamoConnectionConfig): this;
+  setClient(client: any): this;
+  registerEntity(mapping: SingleTableEntityMapping): this;
+  entity<T = any>(entityType: string): EntityQueryBuilder<T>;
+  batchWrite(operations: BatchWriteOperation[]): Promise<void>;
+  transactWrite(operations: TransactWriteOperation[]): Promise<void>;
+  getDriver(): DynamoDBDriver | undefined;
+}
+export { Model, configureModels } from './model';
+export { DynamoDBClient, createClient } from './client';
+export {
+  DynamoDBMigrationDriver,
+  createMigrationDriver,
+  migrateModels,
+} from './migration-driver';
+export {
+  buildMigrationPlan as buildDynamoDBMigrationPlan,
+  extractTableDefinition,
+  extractModelSchema,
+  convertSchemaToDefinition,
+  hashTableDefinition,
+  isDefinitionEqual,
+} from './migrations';
+export { DynamoDBMigrationTracker, MIGRATIONS_TABLE } from './migration-tracker';