dyno-table 2.5.1 → 2.6.0

package/dist/index.d.cts

@@ -1,273 +0,0 @@
-import { c as BatchError, d as ConfigurationError, E as ExpressionError, e as EntityValidationError, K as KeyGenerationError, I as IndexGenerationError, O as OperationError, f as TransactionError, V as ValidationError, g as DynoTableError, h as EntityError } from './index-CPCmWsEv.cjs';
-export { B as BatchBuilder, i as BatchResult, D as DeleteBuilder, j as DeleteOptions, k as ErrorCode, l as ErrorCodes, P as PutBuilder, m as PutOptions, Q as QueryBuilder, n as QueryOptions, T as TransactionBuilder, a as TransactionOptions, U as UpdateBuilder, o as UpdateOptions } from './index-CPCmWsEv.cjs';
-export { C as ComparisonOperator, b as Condition, c as ConditionOperator, E as ExpressionParams, K as KeyConditionOperator, L as LogicalOperator, a as PrimaryKey, P as PrimaryKeyWithoutExpression, d as and, e as attributeExists, f as attributeNotExists, g as beginsWith, h as between, i as contains, j as eq, k as gt, l as gte, m as inArray, n as lt, o as lte, p as ne, q as not, r as or } from './conditions-C8bM__Pn.cjs';
-export { EntityConfig, EntityRepository, IndexDefinition, QueryEntity, QueryRecord, createIndex, createQueries, defineEntity } from './entity.cjs';
-export { Table } from './table.cjs';
-export { partitionKey, sortKey } from './utils.cjs';
-import './types.cjs';
-import '@aws-sdk/lib-dynamodb';
-import './standard-schema.cjs';
-
-/**
- * Factory functions for Expression errors
- */
-declare const ExpressionErrors: {
-    missingAttribute: (conditionType: string, condition: unknown) => ExpressionError;
-    missingValue: (conditionType: string, condition: unknown) => ExpressionError;
-    invalidCondition: (conditionType: string, condition: unknown, suggestion?: string) => ExpressionError;
-    emptyArray: (conditionType: string, providedValue: unknown) => ExpressionError;
-    unknownType: (conditionType: string, condition: unknown) => ExpressionError;
-};
-/**
- * Factory functions for Validation errors
- */
-declare const ValidationErrors: {
-    indexSchemaValidationFailed: (validationIssues: unknown, keyType: "partition" | "sort" | "both") => ValidationError;
-    noUpdateActions: (tableName: string, key: Record<string, unknown>) => ValidationError;
-    conditionRequired: (tableName: string, key: Record<string, unknown>) => ValidationError;
-    queryInputValidationFailed: (entityName: string, queryName: string, validationIssues: unknown, providedInput: unknown) => ValidationError;
-    undefinedValue: (path: string, tableName: string, key: Record<string, unknown>) => ValidationError;
-};
-/**
- * Factory functions for Configuration errors
- */
-declare const ConfigurationErrors: {
-    invalidChunkSize: (size: number) => ConfigurationError;
-    sortKeyRequired: (tableName: string, partitionKey: string, sortKey?: string) => ConfigurationError;
-    sortKeyNotDefined: (tableName: string, partitionKey: string, indexName?: string) => ConfigurationError;
-    gsiNotFound: (indexName: string, tableName: string, availableIndexes: string[]) => ConfigurationError;
-    primaryKeyMissing: (tableName: string, partitionKeyName: string, providedItem: unknown) => ConfigurationError;
-    pkExtractionFailed: (tableName: string, indexName: string, item: unknown, cause?: Error) => ConfigurationError;
-    conditionGenerationFailed: (condition: unknown, suggestion?: string) => ExpressionError;
-};
-/**
- * Factory functions for Operation errors
- */
-declare const OperationErrors: {
-    queryFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
-    scanFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
-    getFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
-    putFailed: (tableName: string, item: unknown, cause?: Error) => OperationError;
-    updateFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
-    deleteFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
-    batchGetFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
-    batchWriteFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
-};
-/**
- * Factory functions for Transaction errors
- */
-declare const TransactionErrors: {
-    transactionFailed: (itemCount: number, context: Record<string, unknown>, cause?: Error) => TransactionError;
-    duplicateItem: (tableName: string, partitionKey: {
-        name: string;
-        value: unknown;
-    }, sortKey?: {
-        name: string;
-        value: unknown;
-    }) => TransactionError;
-    transactionEmpty: () => TransactionError;
-    unsupportedType: (item: unknown) => TransactionError;
-};
-/**
- * Factory functions for Batch errors
- */
-declare const BatchErrors: {
-    batchEmpty: (operation: "write" | "read") => BatchError;
-    unsupportedType: (operation: "write" | "read", item: unknown) => BatchError;
-    batchWriteFailed: (unprocessedItems: unknown[], context: Record<string, unknown>, cause?: Error) => BatchError;
-    batchGetFailed: (unprocessedItems: unknown[], context: Record<string, unknown>, cause?: Error) => BatchError;
-};
-/**
- * Factory functions for Entity errors
- */
-declare const EntityErrors: {
-    validationFailed: (entityName: string, operation: string, validationIssues: unknown, providedData: unknown) => EntityValidationError;
-    queryInputValidationFailed: (entityName: string, queryName: string, validationIssues: unknown, providedInput: unknown) => EntityValidationError;
-    asyncValidationNotSupported: (entityName: string, operation: string) => EntityValidationError;
-    keyGenerationFailed: (entityName: string, operation: string, providedData: unknown, requiredAttributes?: string[], cause?: Error) => KeyGenerationError;
-    keyInvalidFormat: (entityName: string, operation: string, providedData: unknown, generatedKey: unknown) => KeyGenerationError;
-    keyMissingAttributes: (entityName: string, operation: string, missingAttributes: string[], providedData: unknown) => KeyGenerationError;
-};
-/**
- * Factory functions for Index errors
- */
-declare const IndexErrors: {
-    generationFailed: (indexName: string, operation: string, providedItem: unknown, partitionKeyAttribute?: string, sortKeyAttribute?: string, cause?: Error) => IndexGenerationError;
-    missingAttributes: (indexName: string, operation: string, missingAttributes: string[], providedData: unknown, isReadOnly: boolean) => IndexGenerationError;
-    undefinedValues: (indexName: string, operation: string, generatedKey: unknown, providedItem: unknown) => IndexGenerationError;
-    notFound: (requestedIndexes: string[], availableIndexes: string[], entityName?: string, tableName?: string) => IndexGenerationError;
-    readonlyUpdateFailed: (indexName: string, operation: string, providedData: unknown) => IndexGenerationError;
-};
-
-/**
- * Utility functions for error handling
- *
- * This module provides helper functions for wrapping AWS SDK errors,
- * extracting information from errors, and formatting error context.
- */
-
-/**
- * Checks if an error is a DynamoDB conditional check failure
- *
- * @param error - The error to check
- * @returns true if the error is a conditional check failure
- */
-declare function isConditionalCheckFailed(error: unknown): boolean;
-/**
- * Checks if an error is a DynamoDB transaction cancellation
- *
- * @param error - The error to check
- * @returns true if the error is a transaction cancellation
- */
-declare function isTransactionCanceled(error: unknown): boolean;
-/**
- * Checks if an error is a DynamoDB validation exception
- *
- * @param error - The error to check
- * @returns true if the error is a validation exception
- */
-declare function isValidationException(error: unknown): boolean;
-/**
- * Checks if an error is a DynamoDB provisioned throughput exceeded exception
- *
- * @param error - The error to check
- * @returns true if the error is a throughput exceeded exception
- */
-declare function isProvisionedThroughputExceeded(error: unknown): boolean;
-/**
- * Checks if an error is a retryable error
- *
- * Retryable errors include:
- * - ProvisionedThroughputExceededException
- * - ThrottlingException
- * - RequestLimitExceeded
- * - InternalServerError
- * - ServiceUnavailable
- *
- * @param error - The error to check
- * @returns true if the error is retryable
- */
-declare function isRetryableError(error: unknown): boolean;
-/**
- * Extracts the AWS error code from an error
- *
- * @param error - The error to extract the code from
- * @returns The error code, or undefined if not found
- */
-declare function getAwsErrorCode(error: unknown): string | undefined;
-/**
- * Extracts the AWS error message from an error
- *
- * @param error - The error to extract the message from
- * @returns The error message, or undefined if not found
- */
-declare function getAwsErrorMessage(error: unknown): string | undefined;
-/**
- * Attempts to extract required attribute names from an error message
- *
- * This is a best-effort function that looks for common patterns in error
- * messages to identify which attributes are missing or required.
- *
- * @param error - The error to extract attributes from
- * @returns Array of attribute names, or undefined if none found
- */
-declare function extractRequiredAttributes(error: unknown): string[] | undefined;
-/**
- * Formats error context for logging
- *
- * Converts the error context object to a readable string format,
- * handling special types like arrays and nested objects.
- *
- * @param context - The error context to format
- * @param indent - The indentation level (for nested objects)
- * @returns Formatted context string
- */
-declare function formatErrorContext(context: Record<string, unknown>, indent?: number): string;
-/**
- * Creates a detailed error summary including context
- *
- * Useful for logging or displaying error information to developers.
- *
- * @param error - The DynoTableError to summarize
- * @returns Formatted error summary
- */
-declare function getErrorSummary(error: DynoTableError): string;
-/**
- * Type guard to check if an error is a DynoTableError
- *
- * @param error - The error to check
- * @returns true if the error is a DynoTableError
- */
-declare function isDynoTableError(error: unknown): error is DynoTableError;
-/**
- * Type guard to check if an error is a ValidationError
- *
- * @param error - The error to check
- * @returns true if the error is a ValidationError
- */
-declare function isValidationError(error: unknown): error is ValidationError;
-/**
- * Type guard to check if an error is an OperationError
- *
- * @param error - The error to check
- * @returns true if the error is an OperationError
- */
-declare function isOperationError(error: unknown): error is OperationError;
-/**
- * Type guard to check if an error is a TransactionError
- *
- * @param error - The error to check
- * @returns true if the error is a TransactionError
- */
-declare function isTransactionError(error: unknown): error is TransactionError;
-/**
- * Type guard to check if an error is a BatchError
- *
- * @param error - The error to check
- * @returns true if the error is a BatchError
- */
-declare function isBatchError(error: unknown): error is BatchError;
-/**
- * Type guard to check if an error is an ExpressionError
- *
- * @param error - The error to check
- * @returns true if the error is an ExpressionError
- */
-declare function isExpressionError(error: unknown): error is ExpressionError;
-/**
- * Type guard to check if an error is a ConfigurationError
- *
- * @param error - The error to check
- * @returns true if the error is a ConfigurationError
- */
-declare function isConfigurationError(error: unknown): error is ConfigurationError;
-/**
- * Type guard to check if an error is an EntityError
- *
- * @param error - The error to check
- * @returns true if the error is an EntityError
- */
-declare function isEntityError(error: unknown): error is EntityError;
-/**
- * Type guard to check if an error is a KeyGenerationError
- *
- * @param error - The error to check
- * @returns true if the error is a KeyGenerationError
- */
-declare function isKeyGenerationError(error: unknown): error is KeyGenerationError;
-/**
- * Type guard to check if an error is an IndexGenerationError
- *
- * @param error - The error to check
- * @returns true if the error is an IndexGenerationError
- */
-declare function isIndexGenerationError(error: unknown): error is IndexGenerationError;
-/**
- * Type guard to check if an error is an EntityValidationError
- *
- * @param error - The error to check
- * @returns true if the error is an EntityValidationError
- */
-declare function isEntityValidationError(error: unknown): error is EntityValidationError;
-
-export { BatchError, BatchErrors, ConfigurationError, ConfigurationErrors, DynoTableError, EntityError, EntityErrors, EntityValidationError, ExpressionError, ExpressionErrors, IndexErrors, IndexGenerationError, KeyGenerationError, OperationError, OperationErrors, TransactionError, TransactionErrors, ValidationError, ValidationErrors, extractRequiredAttributes, formatErrorContext, getAwsErrorCode, getAwsErrorMessage, getErrorSummary, isBatchError, isConditionalCheckFailed, isConfigurationError, isDynoTableError, isEntityError, isEntityValidationError, isExpressionError, isIndexGenerationError, isKeyGenerationError, isOperationError, isProvisionedThroughputExceeded, isRetryableError, isTransactionCanceled, isTransactionError, isValidationError, isValidationException };

package/dist/standard-schema.d.cts

@@ -1,57 +0,0 @@
-/** The Standard Schema interface. */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-    /** The Standard Schema properties. */
-    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardSchemaV1 {
-    /** The Standard Schema properties interface. */
-    interface Props<Input = unknown, Output = Input> {
-        /** The version number of the standard. */
-        readonly version: 1;
-        /** The vendor name of the schema library. */
-        readonly vendor: string;
-        /** Validates unknown input values. */
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        /** Inferred types associated with the schema. */
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    /** The result interface of the validate function. */
-    type Result<Output> = SuccessResult<Output> | FailureResult;
-    /** The result interface if validation succeeds. */
-    interface SuccessResult<Output> {
-        /** The typed output value. */
-        readonly value: Output;
-        /** The non-existent issues. */
-        readonly issues?: undefined;
-    }
-    /** The result interface if validation fails. */
-    interface FailureResult {
-        /** The issues of failed validation. */
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    /** The issue interface of the failure output. */
-    interface Issue {
-        /** The error message of the issue. */
-        readonly message: string;
-        /** The path of the issue, if any. */
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    /** The path segment interface of the issue. */
-    interface PathSegment {
-        /** The key representing a path segment. */
-        readonly key: PropertyKey;
-    }
-    /** The Standard Schema types interface. */
-    interface Types<Input = unknown, Output = Input> {
-        /** The input type of the schema. */
-        readonly input: Input;
-        /** The output type of the schema. */
-        readonly output: Output;
-    }
-    /** Infers the input type of a Standard Schema. */
-    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-    /** Infers the output type of a Standard Schema. */
-    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-}
-
-export { StandardSchemaV1 };

package/dist/table.d.cts

@@ -1,165 +0,0 @@
-import { P as PutBuilder, G as GetBuilder, Q as QueryBuilder, S as ScanBuilder, D as DeleteBuilder, U as UpdateBuilder, T as TransactionBuilder, B as BatchBuilder, a as TransactionOptions, C as ConditionCheckBuilder, b as BatchWriteOperation } from './index-CPCmWsEv.cjs';
-import { P as PrimaryKeyWithoutExpression, a as PrimaryKey } from './conditions-C8bM__Pn.cjs';
-import { TableConfig, Index, DynamoItem } from './types.cjs';
-import '@aws-sdk/lib-dynamodb';
-
-declare class Table<TConfig extends TableConfig = TableConfig> {
-    private readonly dynamoClient;
-    readonly tableName: string;
-    /**
-     * The column name of the partitionKey for the Table
-     */
-    readonly partitionKey: string;
-    /**
-     * The column name of the sortKey for the Table
-     */
-    readonly sortKey?: string;
-    /**
-     * The Global Secondary Indexes that are configured on this table
-     */
-    readonly gsis: Record<string, Index>;
-    constructor(config: TConfig);
-    private getIndexAttributeNames;
-    protected createKeyForPrimaryIndex(keyCondition: PrimaryKeyWithoutExpression): Record<string, unknown>;
-    /**
-     * Creates a new item in the table, it will fail if the item already exists.
-     *
-     * By default, this method returns the input values passed to the create operation
-     * upon successful creation.
-     *
-     * You can customise the return behaviour by chaining the `.returnValues()` method:
-     *
-     * @param item The item to create
-     * @returns A PutBuilder instance for chaining additional conditions and executing the create operation
-     *
-     * @example
-     * ```ts
-     * // Create with default behavior (returns input values)
-     * const result = await table.create({
-     *   id: 'user-123',
-     *   name: 'John Doe',
-     *   email: 'john@example.com'
-     * }).execute();
-     * console.log(result); // Returns the input object
-     *
-     * // Create with no return value for better performance
-     * await table.create(userData).returnValues('NONE').execute();
-     *
-     * // Create and get fresh data from dynamodb using a strongly consistent read
-     * const freshData = await table.create(userData).returnValues('CONSISTENT').execute();
-     *
-     * // Create and get previous values (if the item was overwritten)
-     * const oldData = await table.create(userData).returnValues('ALL_OLD').execute();
-     * ```
-     */
-    create<T extends DynamoItem>(item: T): PutBuilder<T>;
-    get<T extends DynamoItem>(keyCondition: PrimaryKeyWithoutExpression): GetBuilder<T>;
-    /**
-     * Updates an item in the table
-     *
-     * @param item The item to update
-     * @returns A PutBuilder instance for chaining conditions and executing the put operation
-     */
-    put<T extends DynamoItem>(item: T): PutBuilder<T>;
-    /**
-     * Creates a query builder for complex queries
-     * If useIndex is called on the returned QueryBuilder, it will use the GSI configuration
-     */
-    query<T extends DynamoItem>(keyCondition: PrimaryKey): QueryBuilder<T, TConfig>;
-    /**
-     * Creates a scan builder for scanning the entire table
-     * Use this when you need to:
-     * - Process all items in a table
-     * - Apply filters to a large dataset
-     * - Use a GSI for scanning
-     *
-     * @returns A ScanBuilder instance for chaining operations
-     */
-    scan<T extends DynamoItem>(): ScanBuilder<T, TConfig>;
-    delete(keyCondition: PrimaryKeyWithoutExpression): DeleteBuilder;
-    /**
-     * Updates an item in the table
-     *
-     * @param keyCondition The primary key of the item to update
-     * @returns An UpdateBuilder instance for chaining update operations and conditions
-     */
-    update<T extends DynamoItem>(keyCondition: PrimaryKeyWithoutExpression): UpdateBuilder<T>;
-    /**
-     * Creates a transaction builder for performing multiple operations atomically
-     */
-    transactionBuilder(): TransactionBuilder;
-    /**
-     * Creates a batch builder for performing multiple operations efficiently with optional type inference
-     *
-     * @example Basic Usage
-     * ```typescript
-     * const batch = table.batchBuilder();
-     *
-     * // Add operations
-     * userRepo.create(newUser).withBatch(batch);
-     * orderRepo.get({ id: 'order-1' }).withBatch(batch);
-     *
-     * // Execute operations
-     * const result = await batch.execute();
-     * ```
-     *
-     * @example Typed Usage
-     * ```typescript
-     * // Define entity types for the batch
-     * const batch = table.batchBuilder<{
-     *   User: UserEntity;
-     *   Order: OrderEntity;
-     *   Product: ProductEntity;
-     * }>();
-     *
-     * // Add operations with type information
-     * userRepo.create(newUser).withBatch(batch, 'User');
-     * orderRepo.get({ id: 'order-1' }).withBatch(batch, 'Order');
-     * productRepo.delete({ id: 'old-product' }).withBatch(batch, 'Product');
-     *
-     * // Execute and get typed results
-     * const result = await batch.execute();
-     * const users: UserEntity[] = result.reads.itemsByType.User;
-     * const orders: OrderEntity[] = result.reads.itemsByType.Order;
-     * ```
-     */
-    batchBuilder<TEntities extends Record<string, DynamoItem> = Record<string, DynamoItem>>(): BatchBuilder<TEntities>;
-    /**
-     * Executes a transaction using a callback function
-     *
-     * @param callback A function that receives a transaction context and performs operations on it
-     * @param options Optional transaction options
-     * @returns A promise that resolves when the transaction is complete
-     */
-    transaction(callback: (tx: TransactionBuilder) => Promise<void> | void, options?: TransactionOptions): Promise<void>;
-    /**
-     * Creates a condition check operation for use in transactions
-     *
-     * This is useful for when you require a transaction to succeed only when a specific condition is met on a
-     * a record within the database that you are not directly updating.
-     *
-     * For example, you are updating a record and you want to ensure that another record exists and/or has a specific value before proceeding.
-     */
-    conditionCheck(keyCondition: PrimaryKeyWithoutExpression): ConditionCheckBuilder;
-    /**
-     * Performs a batch get operation to retrieve multiple items at once
-     *
-     * @param keys Array of primary keys to retrieve
-     * @returns A promise that resolves to the retrieved items
-     */
-    batchGet<T extends DynamoItem>(keys: Array<PrimaryKeyWithoutExpression>): Promise<{
-        items: T[];
-        unprocessedKeys: PrimaryKeyWithoutExpression[];
-    }>;
-    /**
-     * Performs a batch write operation to put or delete multiple items at once
-     *
-     * @param operations Array of put or delete operations
-     * @returns A promise that resolves to any unprocessed operations
-     */
-    batchWrite<T extends DynamoItem>(operations: Array<BatchWriteOperation<T>>): Promise<{
-        unprocessedItems: Array<BatchWriteOperation<T>>;
-    }>;
-}
-
-export { Table };

package/dist/types.d.cts

@@ -1,29 +0,0 @@
-import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
-
-type DynamoItem = {
-    [key: string]: unknown;
-};
-interface Index<T extends DynamoItem = DynamoItem> {
-    partitionKey: string;
-    sortKey?: string;
-    /** Function to generate the index key from an item */
-    generateKey?: (item: T, safeParse?: boolean) => {
-        pk: string;
-        sk?: string;
-    };
-    /** Whether the index is read-only */
-    isReadOnly?: boolean;
-}
-interface IndexConfig {
-    partitionKey: string;
-    sortKey?: string;
-    gsis?: Record<string, Index>;
-}
-interface TableConfig {
-    client: DynamoDBDocument;
-    tableName: string;
-    indexes: IndexConfig;
-}
-type GSINames<T extends TableConfig> = keyof NonNullable<T["indexes"]["gsis"]>;
-
-export type { DynamoItem, GSINames, Index, IndexConfig, TableConfig };

package/dist/utils.d.cts

@@ -1,66 +0,0 @@
-type StrictGenerateType<T extends readonly string[]> = {
-    [K in T[number]]: string;
-};
-/**
- * Creates a template function for generating DynamoDB partition keys with dynamic values.
- * Use this function when you need to:
- * - Create consistent partition key patterns with variable parts
- * - Generate partition keys that follow a specific format
- * - Ensure type safety for partition key parameters
- * - Require all parameters to be provided
- *
- * @example
- * ```ts
- * // Define a partition key template
- * const pk = partitionKey`country#${"country"}#enclosure#${"enclosure"}`;
- *
- * // Generate a partition key (all parameters required)
- * const key = pk({ country: "NZ", enclosure: "A1" });
- * // Result: "country#NZ#enclosure#A1"
- *
- * // Type checking ensures all parameters are provided
- * const invalidKey = pk({ country: "NZ" }); // TypeScript error
- * ```
- *
- * @param strings - The static parts of the template string
- * @param keys - The dynamic parts of the template string that will be replaced with values
- *
- * @returns A function that accepts an object with the dynamic values and returns the formatted partition key
- */
-declare function partitionKey<T extends readonly string[]>(strings: TemplateStringsArray, ...keys: T): (params: StrictGenerateType<T>) => string;
-
-type GenerateType<T extends readonly string[], U extends string = never> = T extends [infer F, ...infer R] ? F extends string ? R extends string[] ? ({
-    [K in F | U]: string | number;
-} & Partial<Record<Exclude<T[number], F | U>, never>>) | GenerateType<R, F | U> : never : never : never;
-/**
- * Creates a template function for generating DynamoDB sort keys with dynamic values.
- * Use this function when you need to:
- * - Create consistent sort key patterns with variable parts
- * - Generate sort keys that follow a specific format
- * - Ensure type safety for sort key parameters
- *
- * @example
- * ```ts
- * // Define a sort key template
- * const sk = sortKey`country#${"country"}#enclosure#${"enclosure"}#diet#${"diet"}`;
- *
- * // Generate a sort key with partial parameters
- * const templatedString = sk({ country: "NZ", enclosure: "A1" });
- * // Result: "country#NZ#enclosure#A1#diet#"
- *
- * // Generate a complete sort key
- * const fullKey = sk({ country: "NZ", enclosure: "A1", diet: "carnivore" });
- * // Result: "country#NZ#enclosure#A1#diet#carnivore"
- *
- * // Type checking ensures only valid parameters are used
- * const invalidKey = sk({ country: "NZ", invalid: "value" }); // TypeScript error
- * ```
- *
- * @param strings - The static parts of the template string
- * @param keys - The dynamic parts of the template string that will be replaced with values
- *
- * @returns A function that accepts an object with the dynamic values and returns the formatted sort key
- */
-declare function sortKey<T extends readonly string[]>(strings: TemplateStringsArray, ...keys: T): (params: GenerateType<T>) => string;
-
-export { partitionKey, sortKey };