dynamo-document-builder 0.2.0 → 0.4.0

package/dist/attributes/attribute-map.d.ts

@@ -1,13 +1,14 @@
-import type { NativeAttributeValue } from '@aws-sdk/lib-dynamodb';
-export type AttributeValues = Record<string, NativeAttributeValue>;
-export type AttributeNames = Record<string, string>;
-export type DynamoAttributeExpression = {
+import { NativeAttributeValue } from '@aws-sdk/lib-dynamodb';
+
+type AttributeValues = Record<string, NativeAttributeValue>;
+type AttributeNames = Record<string, string>;
+type DynamoAttributeExpression = {
     ExpressionAttributeValues?: AttributeValues | undefined;
     ExpressionAttributeNames?: AttributeNames | undefined;
 };
-export type AttributeValuePlaceholder = `:${string}`;
-export type AttributeNamePlaceholder = `#${string}`;
-export declare class AttributeExpressionMap {
+type AttributeValuePlaceholder = `:${string}`;
+type AttributeNamePlaceholder = `#${string}`;
+declare class AttributeExpressionMap {
     private attributeNames;
     private reverseLookupNames;
     private names;
@@ -30,3 +31,6 @@ export declare class AttributeExpressionMap {
     getNameCount(): number;
     getValueCount(): number;
 }
+
+export { AttributeExpressionMap };
+export type { AttributeNamePlaceholder, AttributeNames, AttributeValuePlaceholder, AttributeValues, DynamoAttributeExpression };

package/dist/attributes/index.d.ts

@@ -1 +1 @@
-export * from './attribute-map';
+export { AttributeExpressionMap, AttributeNamePlaceholder, AttributeNames, AttributeValuePlaceholder, AttributeValues, DynamoAttributeExpression } from './attribute-map.js';

package/dist/commands/base-command.d.ts

@@ -1,24 +1,27 @@
-import type { TransactWriteOperation } from '@/core/core-types';
-import type { DynamoEntity } from '@/core/entity';
-import type { ConsumedCapacity, ReturnConsumedCapacity } from '@aws-sdk/client-dynamodb';
-import type { ResponseMetadata } from '@aws-sdk/types';
-import type { ZodObject } from 'zod/v4';
-export type BaseCommand<Output, Schema extends ZodObject> = {
+import { TransactWriteOperation } from '../core/core-types.js';
+import { DynamoEntity } from '../core/entity.js';
+import { ReturnConsumedCapacity, ConsumedCapacity } from '@aws-sdk/client-dynamodb';
+import { ResponseMetadata } from '@aws-sdk/types';
+import { ZodObject } from 'zod/v4';
+
+type BaseCommand<Output, Schema extends ZodObject> = {
     execute(entity: DynamoEntity<Schema>): Promise<Output>;
 };
-export type BasePaginatable<Output, Schema extends ZodObject> = {
+type BasePaginatable<Output, Schema extends ZodObject> = {
     executePaginated(entity: DynamoEntity<Schema>): AsyncGenerator<Output, void, unknown>;
 };
-export type WriteTransactable<Schema extends ZodObject> = {
+type WriteTransactable<Schema extends ZodObject> = {
     prepareWriteTransaction(entity: DynamoEntity<Schema>): Promise<TransactWriteOperation>;
 };
-export type BaseConfig = {
+type BaseConfig = {
     skipValidation?: boolean;
     returnConsumedCapacity?: ReturnConsumedCapacity;
     abortController?: AbortController;
     timeoutMs?: number;
 };
-export type BaseResult = {
+type BaseResult = {
     responseMetadata?: ResponseMetadata;
     consumedCapacity?: ConsumedCapacity | undefined;
 };
+
+export type { BaseCommand, BaseConfig, BasePaginatable, BaseResult, WriteTransactable };

package/dist/commands/batch-get.d.ts

@@ -1,17 +1,21 @@
-import type { BaseConfig, BaseCommand, BaseResult } from '@/commands/base-command';
-import type { DynamoEntity } from '@/core/entity';
-import type { EntitySchema } from '@/core/core-types';
-import type { ZodObject } from 'zod/v4';
-export type BatchGetConfig<Schema extends ZodObject> = BaseConfig & {
+import { BaseConfig, BaseResult, BaseCommand } from './base-command.js';
+import { DynamoEntity } from '../core/entity.js';
+import { EntitySchema } from '../core/core-types.js';
+import { ZodObject } from 'zod/v4';
+
+type BatchGetConfig<Schema extends ZodObject> = BaseConfig & {
     keys: Array<Partial<EntitySchema<Schema>>>;
     consistent?: boolean;
 };
-export type BatchGetResult<Schema extends ZodObject> = BaseResult & {
+type BatchGetResult<Schema extends ZodObject> = BaseResult & {
     items: Array<EntitySchema<Schema>>;
     unprocessedKeys?: Array<Partial<EntitySchema<Schema>>>;
 };
-export declare class BatchGet<Schema extends ZodObject> implements BaseCommand<BatchGetResult<Schema>, Schema> {
+declare class BatchGet<Schema extends ZodObject> implements BaseCommand<BatchGetResult<Schema>, Schema> {
     #private;
     constructor(config: BatchGetConfig<Schema>);
     execute(entity: DynamoEntity<Schema>): Promise<BatchGetResult<Schema>>;
 }
+
+export { BatchGet };
+export type { BatchGetConfig, BatchGetResult };

package/dist/commands/batch-write.d.ts

@@ -1,34 +1,40 @@
-import type { BaseConfig, BaseCommand, BaseResult } from '@/commands/base-command';
-import type { DynamoEntity } from '@/core/entity';
-import type { EntitySchema } from '@/core/core-types';
-import type { ItemCollectionMetrics, ReturnItemCollectionMetrics } from '@aws-sdk/client-dynamodb';
-import type { ZodObject } from 'zod/v4';
-export type BatchWriteConfig<Schema extends ZodObject> = BaseConfig & {
+import { DynamoKey } from '../core/key.js';
+import * as zod_v4 from 'zod/v4';
+import { ZodObject } from 'zod/v4';
+import { BaseConfig, BaseResult, BaseCommand } from './base-command.js';
+import { DynamoEntity } from '../core/entity.js';
+import { EntitySchema } from '../core/core-types.js';
+import { ReturnItemCollectionMetrics, ItemCollectionMetrics } from '@aws-sdk/client-dynamodb';
+
+type BatchWriteConfig<Schema extends ZodObject> = BaseConfig & {
     items?: Array<EntitySchema<Schema>>;
     deletes?: Array<Partial<EntitySchema<Schema>>>;
     returnItemCollectionMetrics?: ReturnItemCollectionMetrics;
 };
-export type BatchWriteResult<Schema extends ZodObject> = BaseResult & {
+type BatchWriteResult<Schema extends ZodObject> = BaseResult & {
     unprocessedPuts?: Array<EntitySchema<Schema>>;
     unprocessedDeletes?: Array<Partial<EntitySchema<Schema>>>;
     itemColectionMetrics?: ItemCollectionMetrics;
 };
-export declare class BatchWrite<Schema extends ZodObject> implements BaseCommand<BatchWriteResult<Schema>, Schema> {
+declare class BatchWrite<Schema extends ZodObject> implements BaseCommand<BatchWriteResult<Schema>, Schema> {
     #private;
     constructor(config: BatchWriteConfig<Schema>);
     buildPutRequests(entity: DynamoEntity<Schema>): Promise<{
         PutRequest: {
-            Item: import("zod/v4").infer<Schema> & import("..").DynamoKey;
+            Item: zod_v4.infer<Schema> & DynamoKey;
         };
     }[] | {
         PutRequest: {
-            Item: import("zod/v4").input<Schema> & import("..").DynamoKey;
+            Item: zod_v4.input<Schema> & DynamoKey;
         };
     }[]>;
     buildDeleteRequests(entity: DynamoEntity<Schema>): Promise<{
         DeleteRequest: {
-            Key: import("..").DynamoKey;
+            Key: DynamoKey;
         };
     }[]>;
     execute(entity: DynamoEntity<Schema>): Promise<BatchWriteResult<Schema>>;
 }
+
+export { BatchWrite };
+export type { BatchWriteConfig, BatchWriteResult };

package/dist/commands/condition-check.d.ts

@@ -1,16 +1,20 @@
-import type { Condition } from '@/conditions/condition-types';
-import type { DynamoEntity } from '@/core/entity';
-import type { EntitySchema, TransactWriteOperation } from '@/core/core-types';
-import type { ReturnValuesOnConditionCheckFailure } from '@aws-sdk/client-dynamodb';
-import type { WriteTransactable } from '@/commands/base-command';
-import type { ZodObject } from 'zod/v4';
-export type ConditionCheckConfig<Schema extends ZodObject> = {
+import { Condition } from '../conditions/condition-types.js';
+import { DynamoEntity } from '../core/entity.js';
+import { EntitySchema, TransactWriteOperation } from '../core/core-types.js';
+import { ReturnValuesOnConditionCheckFailure } from '@aws-sdk/client-dynamodb';
+import { WriteTransactable } from './base-command.js';
+import { ZodObject } from 'zod/v4';
+
+type ConditionCheckConfig<Schema extends ZodObject> = {
     key: Partial<EntitySchema<Schema>>;
     condition: Condition;
     returnValuesOnConditionCheckFailure?: ReturnValuesOnConditionCheckFailure;
 };
-export declare class ConditionCheck<Schema extends ZodObject> implements WriteTransactable<Schema> {
+declare class ConditionCheck<Schema extends ZodObject> implements WriteTransactable<Schema> {
     #private;
     constructor(config: ConditionCheckConfig<Schema>);
     prepareWriteTransaction(entity: DynamoEntity<Schema>): Promise<TransactWriteOperation>;
 }
+
+export { ConditionCheck };
+export type { ConditionCheckConfig };

package/dist/commands/conditional-delete.d.ts

@@ -1,21 +1,25 @@
-import type { Condition } from '@/conditions/condition-types';
-import type { DeleteConfig } from '@/commands/delete';
-import type { DynamoEntity } from '@/core/entity';
-import type { EntitySchema, TransactWriteOperation } from '@/core/core-types';
-import type { ItemCollectionMetrics, ReturnValuesOnConditionCheckFailure } from '@aws-sdk/client-dynamodb';
-import type { ZodObject } from 'zod/v4';
-import type { BaseResult, BaseCommand, WriteTransactable } from '@/commands/base-command';
-export type ConditionalDeleteConfig<Schema extends ZodObject> = DeleteConfig<Schema> & {
+import { Condition } from '../conditions/condition-types.js';
+import { DeleteConfig } from './delete.js';
+import { DynamoEntity } from '../core/entity.js';
+import { EntitySchema, TransactWriteOperation } from '../core/core-types.js';
+import { ReturnValuesOnConditionCheckFailure, ItemCollectionMetrics } from '@aws-sdk/client-dynamodb';
+import { ZodObject } from 'zod/v4';
+import { BaseResult, BaseCommand, WriteTransactable } from './base-command.js';
+
+type ConditionalDeleteConfig<Schema extends ZodObject> = DeleteConfig<Schema> & {
     condition: Condition;
     returnValuesOnConditionCheckFailure?: ReturnValuesOnConditionCheckFailure;
 };
-export type ConditionalDeleteResult<Schema extends ZodObject> = BaseResult & {
+type ConditionalDeleteResult<Schema extends ZodObject> = BaseResult & {
     deletedItem?: Partial<EntitySchema<Schema>> | undefined;
     itemCollectionMetrics?: ItemCollectionMetrics;
 };
-export declare class ConditionalDelete<Schema extends ZodObject> implements BaseCommand<ConditionalDeleteResult<Schema>, Schema>, WriteTransactable<Schema> {
+declare class ConditionalDelete<Schema extends ZodObject> implements BaseCommand<ConditionalDeleteResult<Schema>, Schema>, WriteTransactable<Schema> {
     #private;
     constructor(config: ConditionalDeleteConfig<Schema>);
     execute(entity: DynamoEntity<Schema>): Promise<ConditionalDeleteResult<Schema>>;
     prepareWriteTransaction(entity: DynamoEntity<Schema>): Promise<TransactWriteOperation>;
 }
+
+export { ConditionalDelete };
+export type { ConditionalDeleteConfig, ConditionalDeleteResult };

package/dist/commands/conditional-put.d.ts

@@ -1,22 +1,28 @@
-import type { Condition } from '@/conditions/condition-types';
-import type { DynamoEntity } from '@/core/entity';
-import type { EntitySchema, TransactWriteOperation } from '@/core/core-types';
-import type { ItemCollectionMetrics, ReturnValuesOnConditionCheckFailure } from '@aws-sdk/client-dynamodb';
-import type { PutConfig } from '@/commands/put';
-import type { ZodObject } from 'zod/v4';
-import type { BaseResult, BaseCommand, WriteTransactable } from '@/commands/base-command';
-export type ConditionalPutConfig<Schema extends ZodObject> = PutConfig<Schema> & {
+import { DynamoKey } from '../core/key.js';
+import * as zod_v4 from 'zod/v4';
+import { ZodObject } from 'zod/v4';
+import { Condition } from '../conditions/condition-types.js';
+import { DynamoEntity } from '../core/entity.js';
+import { EntitySchema, TransactWriteOperation } from '../core/core-types.js';
+import { ReturnValuesOnConditionCheckFailure, ItemCollectionMetrics } from '@aws-sdk/client-dynamodb';
+import { PutConfig } from './put.js';
+import { BaseResult, BaseCommand, WriteTransactable } from './base-command.js';
+
+type ConditionalPutConfig<Schema extends ZodObject> = PutConfig<Schema> & {
     condition: Condition;
     returnValuesOnConditionCheckFailure?: ReturnValuesOnConditionCheckFailure;
 };
-export type ConditionalPutResult<Schema extends ZodObject> = BaseResult & {
+type ConditionalPutResult<Schema extends ZodObject> = BaseResult & {
     returnItem: EntitySchema<Schema> | undefined;
     itemCollectionMetrics: ItemCollectionMetrics | undefined;
 };
-export declare class ConditionalPut<Schema extends ZodObject> implements BaseCommand<ConditionalPutResult<Schema>, Schema>, WriteTransactable<Schema> {
+declare class ConditionalPut<Schema extends ZodObject> implements BaseCommand<ConditionalPutResult<Schema>, Schema>, WriteTransactable<Schema> {
     #private;
     constructor(config: ConditionalPutConfig<Schema>);
-    buildItem(entity: DynamoEntity<Schema>): Promise<(import("zod/v4").infer<Schema> & import("..").DynamoKey) | (import("zod/v4").input<Schema> & import("..").DynamoKey)>;
+    buildItem(entity: DynamoEntity<Schema>): Promise<(zod_v4.infer<Schema> & DynamoKey) | (zod_v4.input<Schema> & DynamoKey)>;
     execute(entity: DynamoEntity<Schema>): Promise<ConditionalPutResult<Schema>>;
     prepareWriteTransaction(entity: DynamoEntity<Schema>): Promise<TransactWriteOperation>;
 }
+
+export { ConditionalPut };
+export type { ConditionalPutConfig, ConditionalPutResult };

package/dist/commands/conditional-update.d.ts

@@ -1,21 +1,25 @@
-import type { Condition } from '@/conditions/condition-types';
-import type { DynamoEntity } from '@/core/entity';
-import type { EntitySchema, TransactWriteOperation } from '@/core/core-types';
-import type { ItemCollectionMetrics, ReturnValuesOnConditionCheckFailure } from '@aws-sdk/client-dynamodb';
-import type { UpdateConfig } from '@/commands/update';
-import type { ZodObject } from 'zod/v4';
-import type { BaseResult, BaseCommand, WriteTransactable } from '@/commands/base-command';
-export type ConditionalUpdateConfig<Schema extends ZodObject> = UpdateConfig<Schema> & {
+import { Condition } from '../conditions/condition-types.js';
+import { DynamoEntity } from '../core/entity.js';
+import { EntitySchema, TransactWriteOperation } from '../core/core-types.js';
+import { ReturnValuesOnConditionCheckFailure, ItemCollectionMetrics } from '@aws-sdk/client-dynamodb';
+import { UpdateConfig } from './update.js';
+import { ZodObject } from 'zod/v4';
+import { BaseResult, BaseCommand, WriteTransactable } from './base-command.js';
+
+type ConditionalUpdateConfig<Schema extends ZodObject> = UpdateConfig<Schema> & {
     condition: Condition;
     returnValuesOnConditionCheckFailure?: ReturnValuesOnConditionCheckFailure;
 };
-export type ConditionalUpdateResult<Schema extends ZodObject> = BaseResult & {
+type ConditionalUpdateResult<Schema extends ZodObject> = BaseResult & {
     updatedItem?: EntitySchema<Schema> | undefined;
     itemCollectionMetrics?: ItemCollectionMetrics;
 };
-export declare class ConditionalUpdate<Schema extends ZodObject> implements BaseCommand<ConditionalUpdateResult<Schema>, Schema>, WriteTransactable<Schema> {
+declare class ConditionalUpdate<Schema extends ZodObject> implements BaseCommand<ConditionalUpdateResult<Schema>, Schema>, WriteTransactable<Schema> {
     #private;
     constructor(config: ConditionalUpdateConfig<Schema>);
     execute(entity: DynamoEntity<Schema>): Promise<ConditionalUpdateResult<Schema>>;
     prepareWriteTransaction(entity: DynamoEntity<Schema>): Promise<TransactWriteOperation>;
 }
+
+export { ConditionalUpdate };
+export type { ConditionalUpdateConfig, ConditionalUpdateResult };

package/dist/commands/delete.d.ts

@@ -1,20 +1,24 @@
-import type { DynamoEntity } from '@/core/entity';
-import type { EntitySchema, TransactWriteOperation } from '@/core/core-types';
-import type { ItemCollectionMetrics, ReturnItemCollectionMetrics, ReturnValue } from '@aws-sdk/client-dynamodb';
-import type { ZodObject } from 'zod/v4';
-import type { BaseConfig, BaseCommand, BaseResult, WriteTransactable } from '@/commands/base-command';
-export type DeleteConfig<Schema extends ZodObject> = BaseConfig & {
+import { DynamoEntity } from '../core/entity.js';
+import { EntitySchema, TransactWriteOperation } from '../core/core-types.js';
+import { ReturnValue, ReturnItemCollectionMetrics, ItemCollectionMetrics } from '@aws-sdk/client-dynamodb';
+import { ZodObject } from 'zod/v4';
+import { BaseConfig, BaseResult, BaseCommand, WriteTransactable } from './base-command.js';
+
+type DeleteConfig<Schema extends ZodObject> = BaseConfig & {
     key: Partial<EntitySchema<Schema>>;
     returnValues?: ReturnValue;
     returnItemCollectionMetrics?: ReturnItemCollectionMetrics;
 };
-export type DeleteResult<Schema extends ZodObject> = BaseResult & {
+type DeleteResult<Schema extends ZodObject> = BaseResult & {
     deletedItem?: Partial<EntitySchema<Schema>> | undefined;
     itemCollectionMetrics?: ItemCollectionMetrics;
 };
-export declare class Delete<Schema extends ZodObject> implements BaseCommand<DeleteResult<Schema>, Schema>, WriteTransactable<Schema> {
+declare class Delete<Schema extends ZodObject> implements BaseCommand<DeleteResult<Schema>, Schema>, WriteTransactable<Schema> {
     #private;
     constructor(config: DeleteConfig<Schema>);
     execute(entity: DynamoEntity<Schema>): Promise<DeleteResult<Schema>>;
     prepareWriteTransaction(entity: DynamoEntity<Schema>): Promise<TransactWriteOperation>;
 }
+
+export { Delete };
+export type { DeleteConfig, DeleteResult };

package/dist/commands/get.d.ts

@@ -1,16 +1,20 @@
-import type { DynamoEntity } from '@/core/entity';
-import type { BaseConfig, BaseCommand, BaseResult } from '@/commands/base-command';
-import type { ZodObject } from 'zod/v4';
-import type { EntitySchema } from '@/core/core-types';
-export type GetConfig<Schema extends ZodObject> = BaseConfig & {
+import { DynamoEntity } from '../core/entity.js';
+import { BaseConfig, BaseResult, BaseCommand } from './base-command.js';
+import { ZodObject } from 'zod/v4';
+import { EntitySchema } from '../core/core-types.js';
+
+type GetConfig<Schema extends ZodObject> = BaseConfig & {
     key: Partial<EntitySchema<Schema>>;
     consistent?: boolean;
 };
-export type GetResult<Schema extends ZodObject> = BaseResult & {
+type GetResult<Schema extends ZodObject> = BaseResult & {
     item: EntitySchema<Schema> | undefined;
 };
-export declare class Get<Schema extends ZodObject> implements BaseCommand<GetResult<Schema>, Schema> {
+declare class Get<Schema extends ZodObject> implements BaseCommand<GetResult<Schema>, Schema> {
     #private;
     constructor(config: GetConfig<Schema>);
     execute(entity: DynamoEntity<Schema>): Promise<GetResult<Schema>>;
 }
+
+export { Get };
+export type { GetConfig, GetResult };

package/dist/commands/index.d.ts

@@ -1,18 +1,18 @@
-export * from './base-command';
-export * from './get';
-export * from './query';
-export * from './scan';
-export * from './projected-get';
-export * from './projected-query';
-export * from './projected-scan';
-export * from './batch-get';
-export * from './transact-get';
-export * from './put';
-export * from './update';
-export * from './delete';
-export * from './conditional-put';
-export * from './conditional-update';
-export * from './conditional-delete';
-export * from './batch-write';
-export * from './transact-write';
-export * from './condition-check';
+export { BaseCommand, BaseConfig, BasePaginatable, BaseResult, WriteTransactable } from './base-command.js';
+export { Get, GetConfig, GetResult } from './get.js';
+export { Query, QueryConfig, QueryResult } from './query.js';
+export { Scan, ScanConfig, ScanResult } from './scan.js';
+export { ProjectedGet, ProjectedGetConfig, ProjectedGetResult } from './projected-get.js';
+export { ProjectedQuery, ProjectedQueryConfig, ProjectedQueryResult } from './projected-query.js';
+export { ProjectedScan, ProjectedScanConfig, ProjectedScanResult } from './projected-scan.js';
+export { BatchGet, BatchGetConfig, BatchGetResult } from './batch-get.js';
+export { TransactGet, TransactGetConfig, TransactGetResult } from './transact-get.js';
+export { Put, PutConfig, PutResult } from './put.js';
+export { Update, UpdateConfig, UpdateResult } from './update.js';
+export { Delete, DeleteConfig, DeleteResult } from './delete.js';
+export { ConditionalPut, ConditionalPutConfig, ConditionalPutResult } from './conditional-put.js';
+export { ConditionalUpdate, ConditionalUpdateConfig, ConditionalUpdateResult } from './conditional-update.js';
+export { ConditionalDelete, ConditionalDeleteConfig, ConditionalDeleteResult } from './conditional-delete.js';
+export { BatchWrite, BatchWriteConfig, BatchWriteResult } from './batch-write.js';
+export { TransactWrite, TransactWriteConfig, TransactWriteResult } from './transact-write.js';
+export { ConditionCheck, ConditionCheckConfig } from './condition-check.js';

package/dist/commands/projected-get.d.ts

@@ -1,18 +1,22 @@
-import type { DynamoEntity } from '@/core/entity';
-import type { EntitySchema } from '@/core/core-types';
-import type { GetConfig } from '@/commands/get';
-import type { Projection } from '@/projections/projection-types';
-import type { ZodObject } from 'zod/v4';
-import type { BaseResult, BaseCommand } from '@/commands/base-command';
-export type ProjectedGetConfig<Schema extends ZodObject, ProjectionSchema extends ZodObject> = GetConfig<Schema> & {
+import { DynamoEntity } from '../core/entity.js';
+import { EntitySchema } from '../core/core-types.js';
+import { GetConfig } from './get.js';
+import { Projection } from '../projections/projection-types.js';
+import { ZodObject } from 'zod/v4';
+import { BaseResult, BaseCommand } from './base-command.js';
+
+type ProjectedGetConfig<Schema extends ZodObject, ProjectionSchema extends ZodObject> = GetConfig<Schema> & {
     projection: Projection;
     projectionSchema: ProjectionSchema;
 };
-export type ProjectedGetResult<ProjectionSchema extends ZodObject> = BaseResult & {
+type ProjectedGetResult<ProjectionSchema extends ZodObject> = BaseResult & {
     item: EntitySchema<ProjectionSchema> | undefined;
 };
-export declare class ProjectedGet<Schema extends ZodObject, ProjectionSchema extends ZodObject> implements BaseCommand<ProjectedGetResult<ProjectionSchema>, Schema> {
+declare class ProjectedGet<Schema extends ZodObject, ProjectionSchema extends ZodObject> implements BaseCommand<ProjectedGetResult<ProjectionSchema>, Schema> {
     #private;
     constructor(config: ProjectedGetConfig<Schema, ProjectionSchema>);
     execute(entity: DynamoEntity<Schema>): Promise<ProjectedGetResult<ProjectionSchema>>;
 }
+
+export { ProjectedGet };
+export type { ProjectedGetConfig, ProjectedGetResult };

package/dist/commands/projected-query.d.ts

@@ -1,21 +1,22 @@
-import type { DynamoEntity } from '@/core/entity';
-import type { EntitySchema } from '@/core/core-types';
-import type { Projection } from '@/projections/projection-types';
-import type { QueryConfig } from '@/commands/query';
-import type { ZodObject } from 'zod/v4';
-import type { BaseResult, BaseCommand, BasePaginatable } from '@/commands/base-command';
-import { type NativeAttributeValue, type QueryCommandInput, type QueryCommandOutput } from '@aws-sdk/lib-dynamodb';
-export type ProjectedQueryConfig<Schema extends ZodObject, ProjectionSchema extends ZodObject> = QueryConfig<Schema> & {
+import { DynamoEntity } from '../core/entity.js';
+import { EntitySchema } from '../core/core-types.js';
+import { Projection } from '../projections/projection-types.js';
+import { QueryConfig } from './query.js';
+import { ZodObject } from 'zod/v4';
+import { BaseResult, BaseCommand, BasePaginatable } from './base-command.js';
+import { QueryCommandInput, NativeAttributeValue, QueryCommandOutput } from '@aws-sdk/lib-dynamodb';
+
+type ProjectedQueryConfig<Schema extends ZodObject, ProjectionSchema extends ZodObject> = QueryConfig<Schema> & {
     projection: Projection;
     projectionSchema: ProjectionSchema;
 };
-export type ProjectedQueryResult<Schema extends ZodObject, ProjectionSchema extends ZodObject> = BaseResult & {
+type ProjectedQueryResult<Schema extends ZodObject, ProjectionSchema extends ZodObject> = BaseResult & {
     items: EntitySchema<ProjectionSchema>[];
     count: number;
     scannedCount: number;
     lastEvaluatedKey?: Partial<EntitySchema<Schema>> | undefined;
 };
-export declare class ProjectedQuery<Schema extends ZodObject, ProjectedSchema extends ZodObject> implements BaseCommand<ProjectedQueryResult<Schema, ProjectedSchema>, Schema>, BasePaginatable<ProjectedQueryResult<Schema, ProjectedSchema>, Schema> {
+declare class ProjectedQuery<Schema extends ZodObject, ProjectedSchema extends ZodObject> implements BaseCommand<ProjectedQueryResult<Schema, ProjectedSchema>, Schema>, BasePaginatable<ProjectedQueryResult<Schema, ProjectedSchema>, Schema> {
     #private;
     constructor(config: ProjectedQueryConfig<Schema, ProjectedSchema>);
     buildCommandInput(entity: DynamoEntity<Schema>): QueryCommandInput;
@@ -24,3 +25,6 @@ export declare class ProjectedQuery<Schema extends ZodObject, ProjectedSchema ex
     execute(entity: DynamoEntity<Schema>): Promise<ProjectedQueryResult<Schema, ProjectedSchema>>;
     executePaginated(entity: DynamoEntity<Schema>): AsyncGenerator<ProjectedQueryResult<Schema, ProjectedSchema>, void, unknown>;
 }
+
+export { ProjectedQuery };
+export type { ProjectedQueryConfig, ProjectedQueryResult };

package/dist/commands/projected-scan.d.ts

@@ -1,21 +1,22 @@
-import type { DynamoEntity } from '@/core/entity';
-import type { EntitySchema } from '@/core/core-types';
-import type { ScanConfig } from '@/commands/scan';
-import type { Projection } from '@/projections/projection-types';
-import type { ZodObject } from 'zod/v4';
-import type { BaseCommand, BasePaginatable, BaseResult } from '@/commands/base-command';
-import { type NativeAttributeValue, type ScanCommandInput, type ScanCommandOutput } from '@aws-sdk/lib-dynamodb';
-export type ProjectedScanConfig<ProjectionSchema extends ZodObject> = ScanConfig<ProjectionSchema> & {
+import { DynamoEntity } from '../core/entity.js';
+import { EntitySchema } from '../core/core-types.js';
+import { ScanConfig } from './scan.js';
+import { Projection } from '../projections/projection-types.js';
+import { ZodObject } from 'zod/v4';
+import { BaseResult, BaseCommand, BasePaginatable } from './base-command.js';
+import { ScanCommandInput, NativeAttributeValue, ScanCommandOutput } from '@aws-sdk/lib-dynamodb';
+
+type ProjectedScanConfig<ProjectionSchema extends ZodObject> = ScanConfig<ProjectionSchema> & {
     projection: Projection;
     projectionSchema: ProjectionSchema;
 };
-export type ProjectedScanResult<Schema extends ZodObject, ProjectionSchema extends ZodObject> = BaseResult & {
+type ProjectedScanResult<Schema extends ZodObject, ProjectionSchema extends ZodObject> = BaseResult & {
     items: EntitySchema<ProjectionSchema>[];
     count: number;
     scannedCount: number;
     lastEvaluatedKey?: Partial<EntitySchema<Schema>> | undefined;
 };
-export declare class ProjectedScan<Schema extends ZodObject, ProjectedSchema extends ZodObject> implements BaseCommand<ProjectedScanResult<Schema, ProjectedSchema>, Schema>, BasePaginatable<ProjectedScanResult<Schema, ProjectedSchema>, Schema> {
+declare class ProjectedScan<Schema extends ZodObject, ProjectedSchema extends ZodObject> implements BaseCommand<ProjectedScanResult<Schema, ProjectedSchema>, Schema>, BasePaginatable<ProjectedScanResult<Schema, ProjectedSchema>, Schema> {
     #private;
     constructor(config: ProjectedScanConfig<ProjectedSchema>);
     buildCommandInput(entity: DynamoEntity<Schema>): ScanCommandInput;
@@ -24,3 +25,6 @@ export declare class ProjectedScan<Schema extends ZodObject, ProjectedSchema ext
     execute(entity: DynamoEntity<Schema>): Promise<ProjectedScanResult<Schema, ProjectedSchema>>;
     executePaginated(entity: DynamoEntity<Schema>): AsyncGenerator<ProjectedScanResult<Schema, ProjectedSchema>, void, unknown>;
 }
+
+export { ProjectedScan };
+export type { ProjectedScanConfig, ProjectedScanResult };

package/dist/commands/put.d.ts

@@ -1,21 +1,27 @@
-import type { DynamoEntity } from '@/core/entity';
-import type { EntitySchema, TransactWriteOperation } from '@/core/core-types';
-import type { ItemCollectionMetrics, ReturnItemCollectionMetrics, ReturnValue } from '@aws-sdk/client-dynamodb';
-import type { ZodObject } from 'zod/v4';
-import type { BaseConfig, BaseCommand, BaseResult, WriteTransactable } from '@/commands/base-command';
-export type PutConfig<Schema extends ZodObject> = BaseConfig & {
+import { DynamoKey } from '../core/key.js';
+import * as zod_v4 from 'zod/v4';
+import { ZodObject } from 'zod/v4';
+import { DynamoEntity } from '../core/entity.js';
+import { EntitySchema, TransactWriteOperation } from '../core/core-types.js';
+import { ReturnValue, ReturnItemCollectionMetrics, ItemCollectionMetrics } from '@aws-sdk/client-dynamodb';
+import { BaseConfig, BaseResult, BaseCommand, WriteTransactable } from './base-command.js';
+
+type PutConfig<Schema extends ZodObject> = BaseConfig & {
     item: EntitySchema<Schema>;
     returnValues?: ReturnValue;
     returnItemCollectionMetrics?: ReturnItemCollectionMetrics;
 };
-export type PutResult<Schema extends ZodObject> = BaseResult & {
+type PutResult<Schema extends ZodObject> = BaseResult & {
     returnItem: Partial<EntitySchema<Schema>> | undefined;
     itemCollectionMetrics?: ItemCollectionMetrics;
 };
-export declare class Put<Schema extends ZodObject> implements BaseCommand<PutResult<Schema>, Schema>, WriteTransactable<Schema> {
+declare class Put<Schema extends ZodObject> implements BaseCommand<PutResult<Schema>, Schema>, WriteTransactable<Schema> {
     #private;
     constructor(config: PutConfig<Schema>);
-    buildItem(entity: DynamoEntity<Schema>): Promise<(import("zod/v4").infer<Schema> & import("..").DynamoKey) | (import("zod/v4").input<Schema> & import("..").DynamoKey)>;
+    buildItem(entity: DynamoEntity<Schema>): Promise<(zod_v4.infer<Schema> & DynamoKey) | (zod_v4.input<Schema> & DynamoKey)>;
     execute(entity: DynamoEntity<Schema>): Promise<PutResult<Schema>>;
     prepareWriteTransaction(entity: DynamoEntity<Schema>): Promise<TransactWriteOperation>;
 }
+
+export { Put };
+export type { PutConfig, PutResult };

package/dist/commands/query.d.ts

@@ -1,11 +1,12 @@
-import type { Condition } from '@/conditions/condition-types';
-import type { DynamoEntity, EntityKeyInput } from '@/core/entity';
-import type { EntitySchema } from '@/core/core-types';
-import type { Select } from '@aws-sdk/client-dynamodb';
-import type { ZodObject } from 'zod/v4';
-import type { BaseConfig, BaseCommand, BasePaginatable, BaseResult } from '@/commands/base-command';
-import { type QueryCommandInput, type NativeAttributeValue, type QueryCommandOutput } from '@aws-sdk/lib-dynamodb';
-export type QueryConfig<Schema extends ZodObject> = BaseConfig & EntityKeyInput<EntitySchema<Schema>> & {
+import { Condition } from '../conditions/condition-types.js';
+import { EntityKeyInput, DynamoEntity } from '../core/entity.js';
+import { EntitySchema } from '../core/core-types.js';
+import { Select } from '@aws-sdk/client-dynamodb';
+import { ZodObject } from 'zod/v4';
+import { BaseConfig, BaseResult, BaseCommand, BasePaginatable } from './base-command.js';
+import { QueryCommandInput, NativeAttributeValue, QueryCommandOutput } from '@aws-sdk/lib-dynamodb';
+
+type QueryConfig<Schema extends ZodObject> = BaseConfig & EntityKeyInput<EntitySchema<Schema>> & {
     sortKeyCondition?: Condition;
     filter?: Condition;
     limit?: number;
@@ -16,13 +17,13 @@ export type QueryConfig<Schema extends ZodObject> = BaseConfig & EntityKeyInput<
     exclusiveStartKey?: Partial<EntitySchema<Schema>>;
     pageSize?: number;
 };
-export type QueryResult<Schema extends ZodObject> = BaseResult & {
+type QueryResult<Schema extends ZodObject> = BaseResult & {
     items: EntitySchema<Schema>[];
     count: number;
     scannedCount: number;
     lastEvaluatedKey?: Partial<EntitySchema<Schema>> | undefined;
 };
-export declare class Query<Schema extends ZodObject> implements BaseCommand<QueryResult<Schema>, Schema>, BasePaginatable<QueryResult<Schema>, Schema> {
+declare class Query<Schema extends ZodObject> implements BaseCommand<QueryResult<Schema>, Schema>, BasePaginatable<QueryResult<Schema>, Schema> {
     #private;
     constructor(config: QueryConfig<Schema>);
     buildCommandInput(entity: DynamoEntity<Schema>): QueryCommandInput;
@@ -31,3 +32,6 @@ export declare class Query<Schema extends ZodObject> implements BaseCommand<Quer
     execute(entity: DynamoEntity<Schema>): Promise<QueryResult<Schema>>;
     executePaginated(entity: DynamoEntity<Schema>): AsyncGenerator<QueryResult<Schema>, void, unknown>;
 }
+
+export { Query };
+export type { QueryConfig, QueryResult };