bun-query-builder 0.1.9 → 0.1.11

package/dist/dynamodb/migration-driver.d.ts

@@ -0,0 +1,55 @@
+import { DynamoDBClient } from './client';
+import { DynamoDBMigrationTracker } from './migration-tracker';
+import type { DynamoDBClientConfig } from './client';
+import type { DynamoDBMigrationPlan, DynamoDBMigrationOperation, DynamoDBMigrationState } from './migrations';
+import type { DynamoDBTableDefinition, DynamoDBGlobalSecondaryIndex } from '../drivers/dynamodb';
+/**
+ * Create a migration driver instance
+ */
+export declare function createMigrationDriver(config: MigrationDriverConfig): DynamoDBMigrationDriver;
+/**
+ * Migrate models with default configuration
+ */
+export declare function migrateModels(models: any[], config: MigrationDriverConfig): Promise<MigrationResult[]>;
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface MigrationDriverConfig extends DynamoDBClientConfig {
+  dryRun?: boolean
+  verbose?: boolean
+}
+export declare interface MigrationResult {
+  tableName: string
+  success: boolean
+  operations: string[]
+  error?: string
+  state?: DynamoDBMigrationState
+}
+/**
+ * Executes DynamoDB schema migrations
+ */
+export declare class DynamoDBMigrationDriver {
+  private client: DynamoDBClient;
+  private tracker: DynamoDBMigrationTracker;
+  private config: MigrationDriverConfig;
+  constructor(config: MigrationDriverConfig);
+  execute(plan: DynamoDBMigrationPlan): Promise<MigrationResult>;
+  private executeOperation(op: DynamoDBMigrationOperation): Promise<void>;
+  private createTable(definition: DynamoDBTableDefinition): Promise<void>;
+  private deleteTable(tableName: string): Promise<void>;
+  private addGSI(tableName: string, gsi: DynamoDBGlobalSecondaryIndex): Promise<void>;
+  private deleteGSI(tableName: string, indexName: string): Promise<void>;
+  private updateTTL(tableName: string, ttlAttribute: string | null, enabled: boolean): Promise<void>;
+  private updateBillingMode(tableName: string, billingMode: 'PAY_PER_REQUEST' | 'PROVISIONED', provisionedThroughput?: { readCapacityUnits: number; writeCapacityUnits: number }): Promise<void>;
+  private enableStream(tableName: string, viewType: string): Promise<void>;
+  private disableStream(tableName: string): Promise<void>;
+  private executeUpdateTable(input: any): Promise<void>;
+  private executeUpdateTimeToLive(input: any): Promise<void>;
+  private waitForTableActive(tableName: string, maxAttempts?: number): Promise<void>;
+  private waitForGSIActive(tableName: string, indexName: string, maxAttempts?: number): Promise<void>;
+  migrateModel(ModelClass: any): Promise<MigrationResult>;
+  migrateModels(models: any[]): Promise<MigrationResult[]>;
+  getStatus(): Promise<Map<string, DynamoDBMigrationState | null>>;
+  private tableInfoToDefinition(tableInfo: any): DynamoDBTableDefinition;
+  private log(args: any[]): void;
+}

package/dist/dynamodb/migration-tracker.d.ts

@@ -0,0 +1,22 @@
+import { DynamoDBClient } from './client';
+import type { DynamoDBMigrationState } from './migrations';
+import type { DynamoDBTableDefinition } from '../drivers/dynamodb';
+/**
+ * Tracks and manages DynamoDB migration state
+ */
+export declare class DynamoDBMigrationTracker {
+  private client: DynamoDBClient;
+  private initialized: boolean;
+  constructor(client: DynamoDBClient);
+  ensureMigrationsTable(): Promise<void>;
+  private waitForTableActive(tableName: string, maxAttempts?: number): Promise<void>;
+  getLatestState(tableName: string): Promise<DynamoDBMigrationState | null>;
+  getHistory(tableName: string): Promise<DynamoDBMigrationState[]>;
+  recordMigration(tableName: string, definition: DynamoDBTableDefinition, version?: number): Promise<DynamoDBMigrationState>;
+  listTrackedTables(): Promise<string[]>;
+  hasMigrations(tableName: string): Promise<boolean>;
+  deleteMigrationHistory(tableName: string): Promise<void>;
+  private marshallState(state: DynamoDBMigrationState, pk: string, sk: string): Record<string, any>;
+  private unmarshallState(item: Record<string, any>): DynamoDBMigrationState;
+}
+export { MIGRATIONS_TABLE };

package/dist/dynamodb/migrations.d.ts

@@ -0,0 +1,113 @@
+import type { DynamoDBTableDefinition, DynamoDBGlobalSecondaryIndex, DynamoDBAttributeDefinition } from '../drivers/dynamodb';
+export type {
+  DynamoDBTableDefinition,
+  DynamoDBGlobalSecondaryIndex,
+  DynamoDBAttributeDefinition,
+};
+/**
+ * Generate a hash of a table definition for comparison
+ */
+export declare function hashTableDefinition(definition: DynamoDBTableDefinition): string;
+/**
+ * Extract DynamoDB table definition from a Model class
+ */
+export declare function extractTableDefinition(model: any): DynamoDBTableDefinition;
+/**
+ * Extract model schema from a Model class
+ */
+export declare function extractModelSchema(ModelClass: any): DynamoDBModelSchema;
+/**
+ * Convert model schema to DynamoDB table definition
+ */
+export declare function convertSchemaToDefinition(schema: DynamoDBModelSchema): DynamoDBTableDefinition;
+/**
+ * Build a migration plan by comparing current and target table definitions
+ */
+export declare function buildMigrationPlan(current: DynamoDBTableDefinition | null, target: DynamoDBTableDefinition): DynamoDBMigrationPlan;
+/**
+ * Check if two table definitions are equivalent
+ */
+export declare function isDefinitionEqual(a: DynamoDBTableDefinition, b: DynamoDBTableDefinition): boolean;
+/**
+ * Individual migration operation
+ */
+export declare interface DynamoDBMigrationOperation {
+  type: DynamoDBMigrationOperationType
+  tableName: string
+  details: Record<string, any>
+}
+/**
+ * Migration plan containing all operations to execute
+ */
+export declare interface DynamoDBMigrationPlan {
+  tableName: string
+  operations: DynamoDBMigrationOperation[]
+  timestamp: string
+  hash: string
+}
+/**
+ * State of a migrated table stored in the migrations table
+ */
+export declare interface DynamoDBMigrationState {
+  tableName: string
+  hash: string
+  definition: DynamoDBTableDefinition
+  appliedAt: string
+  version: number
+}
+/**
+ * Model definition for extracting DynamoDB schema
+ */
+export declare interface DynamoDBModelSchema {
+  tableName: string
+  pkAttribute: string
+  skAttribute: string
+  pkPrefix: string
+  skPrefix: string
+  entityTypeAttribute: string
+  timestamps: boolean
+  ttlAttribute?: string
+  gsis?: DynamoDBGSIDefinition[]
+  lsis?: DynamoDBLSIDefinition[]
+  billingMode?: 'PAY_PER_REQUEST' | 'PROVISIONED'
+  provisionedThroughput?: {
+    readCapacityUnits: number
+    writeCapacityUnits: number
+  }
+  streamEnabled?: boolean
+  streamViewType?: 'KEYS_ONLY' | 'NEW_IMAGE' | 'OLD_IMAGE' | 'NEW_AND_OLD_IMAGES'
+}
+/**
+ * GSI definition for model schema
+ */
+export declare interface DynamoDBGSIDefinition {
+  indexName: string
+  pkAttribute: string
+  skAttribute?: string
+  projection?: 'ALL' | 'KEYS_ONLY' | string[]
+  provisionedThroughput?: {
+    readCapacityUnits: number
+    writeCapacityUnits: number
+  }
+}
+/**
+ * LSI definition for model schema
+ */
+export declare interface DynamoDBLSIDefinition {
+  indexName: string
+  skAttribute: string
+  projection?: 'ALL' | 'KEYS_ONLY' | string[]
+}
+/**
+ * Migration operation types
+ */
+export type DynamoDBMigrationOperationType = | 'CREATE_TABLE'
+  | 'DELETE_TABLE'
+  | 'ADD_GSI'
+  | 'DELETE_GSI'
+  | 'UPDATE_GSI_THROUGHPUT'
+  | 'UPDATE_TTL'
+  | 'UPDATE_BILLING_MODE'
+  | 'UPDATE_THROUGHPUT'
+  | 'ENABLE_STREAM'
+  | 'DISABLE_STREAM'

package/dist/dynamodb/model.d.ts

@@ -0,0 +1,114 @@
+import { DynamoDBClient, createClient } from './client';
+/**
+ * Configure the global DynamoDB connection for all models
+ */
+export declare function configureModels(config: ModelConfig): void;
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface ModelConfig {
+  region?: string
+  endpoint?: string
+  credentials?: {
+    accessKeyId: string
+    secretAccessKey: string
+    sessionToken?: string
+  }
+}
+export declare interface ModelQueryBuilder<T extends Model> {
+  where(attribute: string, value: any): ModelQueryBuilder<T>
+  where(attribute: string, operator: string, value: any): ModelQueryBuilder<T>
+  whereIn(attribute: string, values: any[]): ModelQueryBuilder<T>
+  whereBetween(attribute: string, start: any, end: any): ModelQueryBuilder<T>
+  whereBeginsWith(attribute: string, prefix: string): ModelQueryBuilder<T>
+  whereExists(attribute: string): ModelQueryBuilder<T>
+  whereNotExists(attribute: string): ModelQueryBuilder<T>
+  orderBy(direction: 'asc' | 'desc'): ModelQueryBuilder<T>
+  limit(count: number): ModelQueryBuilder<T>
+  select(...attributes: string[]): ModelQueryBuilder<T>
+  index(indexName: string): ModelQueryBuilder<T>
+  consistentRead(): ModelQueryBuilder<T>
+  startFrom(key: Record<string, any>): ModelQueryBuilder<T>
+  get(): Promise<T[]>
+  first(): Promise<T | null>
+  count(): Promise<number>
+  paginate(pageSize: number, lastKey?: Record<string, any>): Promise<{ items: T[], lastKey?: Record<string, any> }>
+}
+/**
+ * Abstract base class for DynamoDB models
+ *
+ * Extend this class to create type-safe DynamoDB entities with
+ * Laravel Eloquent-like CRUD operations.
+ */
+export declare abstract class Model {
+  static tableName: string;
+  static pkAttribute: string;
+  static skAttribute: string;
+  static pkPrefix: string;
+  static skPrefix: string;
+  static entityTypeAttribute: string;
+  static keyDelimiter: string;
+  static primaryKey: string;
+  static timestamps: boolean;
+  static createdAtField: string;
+  static updatedAtField: string;
+  protected _attributes: Record<string, any>;
+  protected _original: Record<string, any>;
+  protected _exists: boolean;
+  constructor(attributes?: Record<string, any>);
+  static query<T extends Model>(this: new (...args: any[]) => T): ModelQueryBuilderImpl<T>;
+  static find<T extends Model>(this: new (...args: any[]) => T, id: string): Promise<T | null>;
+  static findOrFail<T extends Model>(this: new (...args: any[]) => T, id: string): Promise<T>;
+  static all<T extends Model>(this: new (...args: any[]) => T): Promise<T[]>;
+  static create<T extends Model>(this: new (...args: any[]) => T, attributes: Record<string, any>): Promise<T>;
+  static updateOrCreate<T extends Model>(this: new (...args: any[]) => T, attributes: Record<string, any>, values: Record<string, any>): Promise<T>;
+  static where<T extends Model>(this: new (...args: any[]) => T, attribute: string, operatorOrValue: any, value?: any): ModelQueryBuilderImpl<T>;
+  static wherePk<T extends Model>(this: new (...args: any[]) => T, value: string): ModelQueryBuilderImpl<T>;
+  getKey(): string;
+  getAttribute(key: string): any;
+  setAttribute(key: string, value: any): this;
+  getAttributes(): Record<string, any>;
+  isDirty(attribute?: string): boolean;
+  getDirty(): Record<string, any>;
+  save(): Promise<this>;
+  update(values: Record<string, any>): Promise<this>;
+  delete(): Promise<boolean>;
+  refresh(): Promise<this>;
+  toObject(): Record<string, any>;
+  toJSON(): Record<string, any>;
+}
+// ============================================================================
+// Query Builder Implementation
+// ============================================================================
+declare class ModelQueryBuilderImpl<T extends Model> implements ModelQueryBuilder<T> {
+  private ModelClass: typeof Model;
+  private _pkValue?: string;
+  private _skCondition?: { type: string, value: any, value2?: any };
+  private _indexName?: string;
+  private _filterConditions: Array<{ attribute: string, operator: string, value?: any, values?: any[] }>;
+  private _projectionAttrs: string[];
+  private _limitValue?: number;
+  private _scanForward: boolean;
+  private _consistentReadValue: boolean;
+  private _startKey?: Record<string, any>;
+  constructor(ModelClass: typeof Model);
+  wherePk(value: string): this;
+  where(attribute: string, operatorOrValue: any, value?: any): this;
+  whereIn(attribute: string, values: any[]): this;
+  whereBetween(attribute: string, start: any, end: any): this;
+  whereBeginsWith(attribute: string, prefix: string): this;
+  whereExists(attribute: string): this;
+  whereNotExists(attribute: string): this;
+  orderBy(direction: 'asc' | 'desc'): this;
+  limit(count: number): this;
+  select(attributes: string[]): this;
+  index(indexName: string): this;
+  consistentRead(): this;
+  startFrom(key: Record<string, any>): this;
+  private buildRequest(): Record<string, any>;
+  get(): Promise<T[]>;
+  first(): Promise<T | null>;
+  count(): Promise<number>;
+  paginate(pageSize: number, lastKey?: Record<string, any>): Promise<{ items: T[], lastKey?: Record<string, any> }>;
+}
+export { DynamoDBClient, createClient } from './client';

package/dist/dynamodb-client.d.ts

@@ -0,0 +1,134 @@
+import type { DynamoDBComparisonOperator, DynamoDBCondition, DynamoDBConfig, DynamoDBDriver, DynamoDBPutItemParams, DynamoDBQueryParams, DynamoDBScanParams, DynamoDBUpdateItemParams, SingleTableEntityMapping,  } from './drivers/dynamodb';
+/**
+ * Create a DynamoDB query builder
+ */
+export declare function createDynamoDBQueryBuilder<T = any>(options: DynamoDBQueryBuilderOptions): DynamoDBQueryBuilder<T>;
+/**
+ * Create a DynamoDB item builder
+ */
+export declare function createDynamoDBItemBuilder<T = any>(options: DynamoDBQueryBuilderOptions): DynamoDBItemBuilder<T>;
+/**
+ * Create a DynamoDB client with fluent query builder methods
+ */
+export declare function createDynamoDBClient(options: DynamoDBQueryBuilderOptions): DynamoDBClientMethods;
+/**
+ * DynamoDB Query Builder Options
+ */
+export declare interface DynamoDBQueryBuilderOptions {
+  config: DynamoDBConfig
+  client?: any
+}
+/**
+ * Result type for DynamoDB operations
+ */
+export declare interface DynamoDBResult<T = any> {
+  items?: T[]
+  item?: T
+  count?: number
+  scannedCount?: number
+  lastEvaluatedKey?: Record<string, any>
+  consumedCapacity?: any
+}
+/**
+ * DynamoDB Client Factory
+ *
+ * Creates a complete DynamoDB client with query builder methods
+ */
+export declare interface DynamoDBClientMethods {
+  query: <T = any>() => DynamoDBQueryBuilder<T>
+  item: <T = any>() => DynamoDBItemBuilder<T>
+  driver: DynamoDBDriver
+  registerEntity: (mapping: SingleTableEntityMapping) => void
+  buildKey: (entityType: string, values: Record<string, any>) => { pk: string, sk: string }
+}
+/**
+ * DynamoDB Query Builder
+ *
+ * Fluent interface for building DynamoDB queries
+ */
+export declare class DynamoDBQueryBuilder<T = any> {
+  private driver: DynamoDBDriver;
+  private client: any;
+  private tableName: string;
+  private indexName?: string;
+  private entityType?: string;
+  private keyConditions: DynamoDBCondition[];
+  private filterConditions: DynamoDBCondition[];
+  private projectionAttrs: string[];
+  private limitValue?: number;
+  private scanForward: boolean;
+  private consistentReadValue: boolean;
+  private startKey?: Record<string, any>;
+  constructor(options: DynamoDBQueryBuilderOptions);
+  table(tableName: string): this;
+  index(indexName: string): this;
+  entity(entityType: string): this;
+  whereKey(attribute: string, operator: DynamoDBComparisonOperator, value: any): this;
+  wherePartitionKey(attribute: string, value: any): this;
+  whereSortKey(attribute: string, value: any): this;
+  whereSortKeyBeginsWith(attribute: string, prefix: string): this;
+  whereSortKeyBetween(attribute: string, start: any, end: any): this;
+  where(attribute: string, operator: DynamoDBComparisonOperator | 'contains' | 'attribute_exists' | 'attribute_not_exists' | 'IN', value?: any): this;
+  whereEquals(attribute: string, value: any): this;
+  whereLessThan(attribute: string, value: any): this;
+  whereLessThanOrEqual(attribute: string, value: any): this;
+  whereGreaterThan(attribute: string, value: any): this;
+  whereGreaterThanOrEqual(attribute: string, value: any): this;
+  whereBetween(attribute: string, start: any, end: any): this;
+  whereBeginsWith(attribute: string, prefix: string): this;
+  whereContains(attribute: string, value: any): this;
+  whereExists(attribute: string): this;
+  whereNotExists(attribute: string): this;
+  whereIn(attribute: string, values: any[]): this;
+  select(attributes: string[]): this;
+  limit(count: number): this;
+  ascending(): this;
+  descending(): this;
+  consistentRead(value?: boolean): this;
+  startFrom(key: Record<string, any>): this;
+  buildQueryParams(): DynamoDBQueryParams;
+  buildScanParams(): DynamoDBScanParams;
+  toQueryRequest(): Record<string, any>;
+  toScanRequest(): Record<string, any>;
+  query(): Promise<DynamoDBResult<T>>;
+  scan(): Promise<DynamoDBResult<T>>;
+  getAll(): Promise<T[]>;
+  first(): Promise<T | undefined>;
+  count(): Promise<number>;
+  reset(): this;
+}
+/**
+ * DynamoDB Item Builder for Put/Update operations
+ */
+export declare class DynamoDBItemBuilder<T = any> {
+  private driver: DynamoDBDriver;
+  private client: any;
+  private tableName: string;
+  private itemData: Record<string, any>;
+  private keyData: Record<string, any>;
+  private updateExpressions: DynamoDBUpdateItemParams['updateExpressions'];
+  private conditionExpr?: string;
+  private returnValuesOption: DynamoDBPutItemParams['returnValues'];
+  constructor(options: DynamoDBQueryBuilderOptions);
+  table(tableName: string): this;
+  key(key: Record<string, any>): this;
+  item(data: Record<string, any>): this;
+  set(attribute: string, value: any): this;
+  setMany(values: Record<string, any>): this;
+  remove(attribute: string): this;
+  add(attribute: string, value: any): this;
+  deleteFromSet(attribute: string, values: any): this;
+  condition(expression: string): this;
+  ifNotExists(attribute?: string): this;
+  ifExists(attribute?: string): this;
+  returnOld(): this;
+  returnNew(): this;
+  toPutRequest(): Record<string, any>;
+  toUpdateRequest(): Record<string, any>;
+  toDeleteRequest(): Record<string, any>;
+  toGetRequest(): Record<string, any>;
+  put(): Promise<T | undefined>;
+  update(): Promise<T | undefined>;
+  delete(): Promise<T | undefined>;
+  get(): Promise<T | undefined>;
+}

package/dist/dynamodb-single-table.d.ts

@@ -0,0 +1,140 @@
+import { DynamoDBQueryBuilder } from './dynamodb-client';
+import type { DynamoDBQueryBuilderOptions } from './dynamodb-client';
+import type { DynamoDBTableDefinition,  } from './drivers/dynamodb';
+/**
+ * Create a single table manager
+ */
+export declare function createSingleTableManager(config: SingleTableConfig): SingleTableManager;
+/**
+ * Create a repository for an entity
+ */
+export declare function createRepository<T extends Record<string, any>>(manager: SingleTableManager, entityName: string, options: DynamoDBQueryBuilderOptions): SingleTableRepository<T>;
+/**
+ * Common single table design patterns
+ */
+export declare const SingleTablePatterns: {
+  /**
+   * User with profile pattern
+   * PK: USER#<userId>
+   * SK: PROFILE for metadata, or related items like ORDER#<orderId>
+   */
+  simpleEntity: (entityName: string, idField: string?) => any;
+  /**
+   * One-to-many relationship pattern
+   * Parent: PK=PARENT#<parentId>, SK=METADATA
+   * Child: PK=PARENT#<parentId>, SK=CHILD#<childId>
+   */
+  oneToMany: ( parentEntity: string, childEntity: string, parentIdField: string?, childIdField: string?, ) => unknown;
+  /**
+   * Many-to-many relationship pattern using adjacency list
+   * Entity: PK=ENTITY#<entityId>, SK=METADATA
+   * Relationship: PK=ENTITY#<entityId>, SK=RELATED#<relatedId>
+   * Inverse: PK=ENTITY#<relatedId>, SK=RELATED#<entityId> (via GSI)
+   */
+  manyToMany: ( entityName: string, relationName: string, idField: string?, relatedIdField: string?, ) => unknown;
+  /**
+   * Hierarchical data pattern (e.g., org chart, file system)
+   * PK: ROOT#<rootId>
+   * SK: PATH#<path> (e.g., PATH#/folder1/folder2/file)
+   */
+  hierarchical: (entityName: string, rootIdField: string?, pathField: string?) => any
+};
+/**
+ * Entity definition for single table design
+ */
+export declare interface SingleTableEntity {
+  name: string
+  pkPattern: string
+  skPattern: string
+  keyFields: string[]
+  indexes?: {
+    /** GSI name */
+    name: string
+    /** Pattern for GSI partition key */
+    pkPattern: string
+    /** Pattern for GSI sort key */
+    skPattern?: string
+  }[]
+  schema?: Record<string, {
+    type: 'string' | 'number' | 'boolean' | 'list' | 'map' | 'set'
+    required?: boolean
+  }>
+}
+/**
+ * Single table design configuration
+ */
+export declare interface SingleTableConfig {
+  tableName: string
+  pkAttribute?: string
+  skAttribute?: string
+  typeAttribute?: string
+  indexes?: {
+    name: string
+    pkAttribute: string
+    skAttribute?: string
+  }[]
+  entities: SingleTableEntity[]
+}
+/**
+ * Single Table Design Manager
+ *
+ * Manages entity mappings and provides utilities for working with
+ * single table design patterns.
+ */
+export declare class SingleTableManager {
+  private config: SingleTableConfig;
+  private entities: Map<string, SingleTableEntity>;
+  private pkAttribute: string;
+  private skAttribute: string;
+  private typeAttribute: string;
+  constructor(config: SingleTableConfig);
+  getEntity(name: string): SingleTableEntity | undefined;
+  registerEntity(entity: SingleTableEntity): void;
+  buildKey(entityName: string, data: Record<string, any>): { pk: string, sk: string };
+  buildGSIKey(entityName: string, indexName: string, data: Record<string, any>): { pk: string, sk?: string };
+  createItem(entityName: string, data: Record<string, any>): Record<string, any>;
+  parseEntityType(item: Record<string, any>): string | undefined;
+  parseItem<T = any>(item: Record<string, any>): { type: string, data: T } | undefined;
+  getEntityPrefix(entityName: string): string;
+  generateTableDefinition(): DynamoDBTableDefinition;
+  private interpolatePattern(pattern: string, values: Record<string, any>): string;
+}
+/**
+ * Single Table Entity Repository
+ *
+ * Provides CRUD operations for a specific entity type in a single table design.
+ */
+export declare class SingleTableRepository<T extends Record<string, any>> {
+  private manager: SingleTableManager;
+  private entityName: string;
+  private options: DynamoDBQueryBuilderOptions;
+  constructor(manager: SingleTableManager, entityName: string, options: DynamoDBQueryBuilderOptions);
+  create(data: T): Promise<T>;
+  get(keyData: Partial<T>): Promise<T | undefined>;
+  update(keyData: Partial<T>, updates: Partial<T>): Promise<T | undefined>;
+  delete(keyData: Partial<T>): Promise<boolean>;
+  query(): SingleTableQueryBuilder<T>;
+  findAll(): Promise<T[]>;
+}
+/**
+ * Query builder for single table entity queries
+ */
+export declare class SingleTableQueryBuilder<T> {
+  private manager: SingleTableManager;
+  private entityName: string;
+  private options: DynamoDBQueryBuilderOptions;
+  private builder: DynamoDBQueryBuilder<Record<string, any>>;
+  private pkValue?: string;
+  private skConditions: { operator: string, value: any, values?: any[] }[];
+  constructor(manager: SingleTableManager, entityName: string, options: DynamoDBQueryBuilderOptions);
+  wherePartitionKey(pkData: Record<string, any>): this;
+  whereSortKey(skData: Record<string, any>): this;
+  whereSortKeyBeginsWith(prefix: string): this;
+  useIndex(indexName: string, pkData: Record<string, any>): this;
+  where(attribute: string, operator: any, value?: any): this;
+  select(attributes: string[]): this;
+  limit(count: number): this;
+  descending(): this;
+  execute(): Promise<T[]>;
+  first(): Promise<T | undefined>;
+}