commandkit 1.2.0-rc.12 → 1.2.0-rc.13

package/dist/kv/kv.d.ts

@@ -1,5 +1,4 @@
-import "../constants-CCFSX2NG.js";
-import { SerializedValue } from "../serde-D4H23l2F.js";
+import { SerializedValue } from "./serde.js";
 import { DatabaseSync } from "node:sqlite";
 
 //#region src/kv/kv.d.ts
@@ -46,342 +45,342 @@ declare class KV implements Disposable, AsyncDisposable {
   private db;
   private statements;
   /**
-   * Creates a new KV store instance
-   *
-   * @param path - Database file path, buffer, URL, or existing DatabaseSync instance
-   * @param options - Configuration options for the KV store
-   */
+       * Creates a new KV store instance
+       *
+       * @param path - Database file path, buffer, URL, or existing DatabaseSync instance
+       * @param options - Configuration options for the KV store
+       */
   constructor(path: string | Buffer | URL | DatabaseSync, options?: KvOptions);
   /**
-   * Gets the current timestamp in milliseconds
-   */
+       * Gets the current timestamp in milliseconds
+       */
   private getCurrentTime;
   /**
-   * Checks if the database connection is open
-   *
-   * @returns `true` if the database is open, `false` otherwise
-   */
+       * Checks if the database connection is open
+       *
+       * @returns `true` if the database is open, `false` otherwise
+       */
   isOpen(): boolean;
   /**
-   * Gets the underlying SQLite database instance
-   *
-   * @returns The DatabaseSync instance
-   */
+       * Gets the underlying SQLite database instance
+       *
+       * @returns The DatabaseSync instance
+       */
   getDatabase(): DatabaseSync;
   /**
-   * Closes the database connection
-   */
+       * Closes the database connection
+       */
   close(): void;
   /**
-   * Disposable implementation - closes the database when disposed
-   */
+       * Disposable implementation - closes the database when disposed
+       */
   [Symbol.dispose](): void;
   /**
-   * AsyncDisposable implementation - closes the database when disposed
-   */
+       * AsyncDisposable implementation - closes the database when disposed
+       */
   [Symbol.asyncDispose](): Promise<void>;
   /**
-   * Retrieves a value by key
-   *
-   * @param key - The key to retrieve (supports dot notation for nested properties)
-   * @returns The value associated with the key, or `undefined` if not found or expired
-   *
-   * @example
-   * ```typescript
-   * // Store an object
-   * kv.set('user:123', { name: 'John', age: 30, settings: { theme: 'dark' } });
-   *
-   * // Get the entire object
-   * const user = kv.get('user:123');
-   * // { name: 'John', age: 30, settings: { theme: 'dark' } }
-   *
-   * // Get nested properties using dot notation
-   * const name = kv.get('user:123.name'); // 'John'
-   * const theme = kv.get('user:123.settings.theme'); // 'dark'
-   * ```
-   */
+       * Retrieves a value by key
+       *
+       * @param key - The key to retrieve (supports dot notation for nested properties)
+       * @returns The value associated with the key, or `undefined` if not found or expired
+       *
+       * @example
+       * ```typescript
+       * // Store an object
+       * kv.set('user:123', { name: 'John', age: 30, settings: { theme: 'dark' } });
+       *
+       * // Get the entire object
+       * const user = kv.get('user:123');
+       * // { name: 'John', age: 30, settings: { theme: 'dark' } }
+       *
+       * // Get nested properties using dot notation
+       * const name = kv.get('user:123.name'); // 'John'
+       * const theme = kv.get('user:123.settings.theme'); // 'dark'
+       * ```
+       */
   get<T = any>(key: string): T | undefined;
   /**
-   * Sets a key-value pair
-   *
-   * @param key - The key to set (supports dot notation for nested properties)
-   * @param value - The value to associate with the key (any JSON-serializable type)
-   *
-   * @example
-   * ```typescript
-   * // Store primitive values
-   * kv.set('counter', 42);
-   * kv.set('active', true);
-   * kv.set('name', 'John');
-   *
-   * // Store objects
-   * kv.set('user:123', { name: 'John', age: 30 });
-   *
-   * // Store arrays
-   * kv.set('tags', ['javascript', 'typescript', 'sqlite']);
-   *
-   * // Store dates
-   * kv.set('created', new Date());
-   *
-   * // Store maps and sets
-   * kv.set('permissions', new Map([['admin', true], ['user', false]]));
-   * kv.set('unique_ids', new Set([1, 2, 3, 4, 5]));
-   *
-   * // Use dot notation for nested properties
-   * kv.set('user:123.settings.theme', 'dark');
-   * kv.set('user:123.settings.notifications', true);
-   * ```
-   */
+       * Sets a key-value pair
+       *
+       * @param key - The key to set (supports dot notation for nested properties)
+       * @param value - The value to associate with the key (any JSON-serializable type)
+       *
+       * @example
+       * ```typescript
+       * // Store primitive values
+       * kv.set('counter', 42);
+       * kv.set('active', true);
+       * kv.set('name', 'John');
+       *
+       * // Store objects
+       * kv.set('user:123', { name: 'John', age: 30 });
+       *
+       * // Store arrays
+       * kv.set('tags', ['javascript', 'typescript', 'sqlite']);
+       *
+       * // Store dates
+       * kv.set('created', new Date());
+       *
+       * // Store maps and sets
+       * kv.set('permissions', new Map([['admin', true], ['user', false]]));
+       * kv.set('unique_ids', new Set([1, 2, 3, 4, 5]));
+       *
+       * // Use dot notation for nested properties
+       * kv.set('user:123.settings.theme', 'dark');
+       * kv.set('user:123.settings.notifications', true);
+       * ```
+       */
   set(key: string, value: any): void;
   /**
-   * Sets a key-value pair with expiration
-   *
-   * @param key - The key to set (supports dot notation for nested properties)
-   * @param value - The value to associate with the key (any JSON-serializable type)
-   * @param ttl - Time to live in milliseconds
-   *
-   * @example
-   * ```typescript
-   * // Set with 1 hour expiration
-   * kv.setex('session:123', { userId: 123, token: 'abc123' }, 60 * 60 * 1000);
-   *
-   * // Set with 5 minutes expiration
-   * kv.setex('temp:data', { cached: true, timestamp: Date.now() }, 5 * 60 * 1000);
-   *
-   * // Use dot notation with expiration
-   * kv.setex('user:123.temp_settings', { theme: 'light' }, 30 * 60 * 1000);
-   * ```
-   */
+       * Sets a key-value pair with expiration
+       *
+       * @param key - The key to set (supports dot notation for nested properties)
+       * @param value - The value to associate with the key (any JSON-serializable type)
+       * @param ttl - Time to live in milliseconds
+       *
+       * @example
+       * ```typescript
+       * // Set with 1 hour expiration
+       * kv.setex('session:123', { userId: 123, token: 'abc123' }, 60 * 60 * 1000);
+       *
+       * // Set with 5 minutes expiration
+       * kv.setex('temp:data', { cached: true, timestamp: Date.now() }, 5 * 60 * 1000);
+       *
+       * // Use dot notation with expiration
+       * kv.setex('user:123.temp_settings', { theme: 'light' }, 30 * 60 * 1000);
+       * ```
+       */
   setex(key: string, value: any, ttl: number): void;
   /**
-   * Performs mathematical operations on numeric values in the KV store
-   *
-   * @param key - The key to perform math operation on (supports dot notation for nested properties)
-   * @param operator - The mathematical operator to apply
-   * @param value - The value to use in the operation
-   * @returns The updated value after the mathematical operation
-   * @throws Error if the existing value is not numeric or if the operation is invalid
-   *
-   * @example
-   * ```typescript
-   * // Initialize a counter
-   * kv.set('counter', 10);
-   *
-   * // Increment by 5
-   * const result1 = kv.math('counter', '+', 5); // 15
-   *
-   * // Multiply by 2
-   * const result2 = kv.math('counter', '*', 2); // 30
-   *
-   * // Use with bigint
-   * kv.set('big_counter', BigInt(1000));
-   * const result3 = kv.math('big_counter', '+', BigInt(500)); // 1500n
-   *
-   * // Use with dot notation
-   * kv.set('user:123', { score: 100, level: 5 });
-   * const result4 = kv.math('user:123.score', '+', 50); // 150
-   * ```
-   */
+       * Performs mathematical operations on numeric values in the KV store
+       *
+       * @param key - The key to perform math operation on (supports dot notation for nested properties)
+       * @param operator - The mathematical operator to apply
+       * @param value - The value to use in the operation
+       * @returns The updated value after the mathematical operation
+       * @throws Error if the existing value is not numeric or if the operation is invalid
+       *
+       * @example
+       * ```typescript
+       * // Initialize a counter
+       * kv.set('counter', 10);
+       *
+       * // Increment by 5
+       * const result1 = kv.math('counter', '+', 5); // 15
+       *
+       * // Multiply by 2
+       * const result2 = kv.math('counter', '*', 2); // 30
+       *
+       * // Use with bigint
+       * kv.set('big_counter', BigInt(1000));
+       * const result3 = kv.math('big_counter', '+', BigInt(500)); // 1500n
+       *
+       * // Use with dot notation
+       * kv.set('user:123', { score: 100, level: 5 });
+       * const result4 = kv.math('user:123.score', '+', 50); // 150
+       * ```
+       */
   math(key: string, operator: KvMathOperator, value: number | bigint): number | bigint;
   /**
-   * Sets expiration for an existing key
-   *
-   * @param key - The key to set expiration for
-   * @param ttl - Time to live in milliseconds
-   * @returns `true` if the key exists and expiration was set, `false` otherwise
-   *
-   * @example
-   * ```typescript
-   * kv.set('user:123', { name: 'John', age: 30 });
-   *
-   * // Set 30 minute expiration
-   * if (kv.expire('user:123', 30 * 60 * 1000)) {
-   *   console.log('Expiration set successfully');
-   * }
-   * ```
-   */
+       * Sets expiration for an existing key
+       *
+       * @param key - The key to set expiration for
+       * @param ttl - Time to live in milliseconds
+       * @returns `true` if the key exists and expiration was set, `false` otherwise
+       *
+       * @example
+       * ```typescript
+       * kv.set('user:123', { name: 'John', age: 30 });
+       *
+       * // Set 30 minute expiration
+       * if (kv.expire('user:123', 30 * 60 * 1000)) {
+       *   console.log('Expiration set successfully');
+       * }
+       * ```
+       */
   expire(key: string, ttl: number): boolean;
   /**
-   * Gets the time to live for a key
-   *
-   * @param key - The key to check
-   * @returns Time to live in milliseconds, or `-1` if the key doesn't exist, or `-2` if the key has no expiration
-   *
-   * @example
-   * ```typescript
-   * const ttl = kv.ttl('user:123');
-   * if (ttl > 0) {
-   *   console.log(`Key expires in ${ttl}ms`);
-   * } else if (ttl === -2) {
-   *   console.log('Key has no expiration');
-   * } else {
-   *   console.log('Key does not exist');
-   * }
-   * ```
-   */
+       * Gets the time to live for a key
+       *
+       * @param key - The key to check
+       * @returns Time to live in milliseconds, or `-1` if the key doesn't exist, or `-2` if the key has no expiration
+       *
+       * @example
+       * ```typescript
+       * const ttl = kv.ttl('user:123');
+       * if (ttl > 0) {
+       *   console.log(`Key expires in ${ttl}ms`);
+       * } else if (ttl === -2) {
+       *   console.log('Key has no expiration');
+       * } else {
+       *   console.log('Key does not exist');
+       * }
+       * ```
+       */
   ttl(key: string): number;
   /**
-   * Deletes a key-value pair
-   *
-   * @param key - The key to delete
-   *
-   * @example
-   * ```typescript
-   * kv.delete('user:123');
-   * kv.delete('user:123.settings.theme'); // Delete nested property
-   * ```
-   */
+       * Deletes a key-value pair
+       *
+       * @param key - The key to delete
+       *
+       * @example
+       * ```typescript
+       * kv.delete('user:123');
+       * kv.delete('user:123.settings.theme'); // Delete nested property
+       * ```
+       */
   delete(key: string): void;
   /**
-   * Checks if a key exists and is not expired
-   *
-   * @param key - The key to check
-   * @returns `true` if the key exists and is not expired, `false` otherwise
-   *
-   * @example
-   * ```typescript
-   * if (kv.has('user:123')) {
-   *   console.log('User exists and is not expired');
-   * }
-   *
-   * if (kv.has('user:123.settings.theme')) {
-   *   console.log('Theme setting exists');
-   * }
-   * ```
-   */
+       * Checks if a key exists and is not expired
+       *
+       * @param key - The key to check
+       * @returns `true` if the key exists and is not expired, `false` otherwise
+       *
+       * @example
+       * ```typescript
+       * if (kv.has('user:123')) {
+       *   console.log('User exists and is not expired');
+       * }
+       *
+       * if (kv.has('user:123.settings.theme')) {
+       *   console.log('Theme setting exists');
+       * }
+       * ```
+       */
   has(key: string): boolean;
   /**
-   * Gets all keys in the current namespace (excluding expired keys)
-   *
-   * @returns Array of all non-expired keys
-   *
-   * @example
-   * ```typescript
-   * const keys = kv.keys();
-   * console.log('All keys:', keys);
-   * ```
-   */
+       * Gets all keys in the current namespace (excluding expired keys)
+       *
+       * @returns Array of all non-expired keys
+       *
+       * @example
+       * ```typescript
+       * const keys = kv.keys();
+       * console.log('All keys:', keys);
+       * ```
+       */
   keys(): string[];
   /**
-   * Gets all values in the current namespace (excluding expired keys)
-   *
-   * @returns Array of all non-expired values
-   *
-   * @example
-   * ```typescript
-   * const values = kv.values();
-   * console.log('All values:', values);
-   * ```
-   */
+       * Gets all values in the current namespace (excluding expired keys)
+       *
+       * @returns Array of all non-expired values
+       *
+       * @example
+       * ```typescript
+       * const values = kv.values();
+       * console.log('All values:', values);
+       * ```
+       */
   values(): any[];
   /**
-   * Gets the total number of key-value pairs in the current namespace (excluding expired keys)
-   *
-   * @returns The count of non-expired key-value pairs
-   *
-   * @example
-   * ```typescript
-   * const count = kv.count();
-   * console.log(`Total entries: ${count}`);
-   * ```
-   */
+       * Gets the total number of key-value pairs in the current namespace (excluding expired keys)
+       *
+       * @returns The count of non-expired key-value pairs
+       *
+       * @example
+       * ```typescript
+       * const count = kv.count();
+       * console.log(`Total entries: ${count}`);
+       * ```
+       */
   count(): number;
   /**
-   * Removes all key-value pairs from the current namespace
-   *
-   * @example
-   * ```typescript
-   * kv.clear(); // Removes all entries in current namespace
-   * ```
-   */
+       * Removes all key-value pairs from the current namespace
+       *
+       * @example
+       * ```typescript
+       * kv.clear(); // Removes all entries in current namespace
+       * ```
+       */
   clear(): void;
   /**
-   * Gets all key-value pairs as an object (excluding expired keys)
-   *
-   * @returns Object with all non-expired key-value pairs
-   *
-   * @example
-   * ```typescript
-   * const all = kv.all();
-   * console.log('All entries:', all);
-   * // Output: { 'key1': value1, 'key2': value2 }
-   * ```
-   */
+       * Gets all key-value pairs as an object (excluding expired keys)
+       *
+       * @returns Object with all non-expired key-value pairs
+       *
+       * @example
+       * ```typescript
+       * const all = kv.all();
+       * console.log('All entries:', all);
+       * // Output: { 'key1': value1, 'key2': value2 }
+       * ```
+       */
   all(): Record<string, any>;
   /**
-   * Gets all available namespaces (tables) in the database
-   *
-   * @returns Array of namespace names
-   *
-   * @example
-   * ```typescript
-   * const namespaces = kv.namespaces();
-   * console.log('Available namespaces:', namespaces);
-   * ```
-   */
+       * Gets all available namespaces (tables) in the database
+       *
+       * @returns Array of namespace names
+       *
+       * @example
+       * ```typescript
+       * const namespaces = kv.namespaces();
+       * console.log('Available namespaces:', namespaces);
+       * ```
+       */
   namespaces(): string[];
   /**
-   * Gets the current namespace name
-   *
-   * @returns The current namespace string
-   */
+       * Gets the current namespace name
+       *
+       * @returns The current namespace string
+       */
   getCurrentNamespace(): string;
   /**
-   * Creates a new KV instance with a different namespace
-   *
-   * @param namespace - The namespace to use for the new instance
-   * @returns A new KV instance with the specified namespace
-   *
-   * @example
-   * ```typescript
-   * const userKv = kv.namespace('users');
-   * const configKv = kv.namespace('config');
-   *
-   * userKv.set('123', { name: 'John', age: 30 });
-   * configKv.set('theme', 'dark');
-   * ```
-   */
+       * Creates a new KV instance with a different namespace
+       *
+       * @param namespace - The namespace to use for the new instance
+       * @returns A new KV instance with the specified namespace
+       *
+       * @example
+       * ```typescript
+       * const userKv = kv.namespace('users');
+       * const configKv = kv.namespace('config');
+       *
+       * userKv.set('123', { name: 'John', age: 30 });
+       * configKv.set('theme', 'dark');
+       * ```
+       */
   namespace(namespace: string): KV;
   /**
-   * Iterator implementation for iterating over all non-expired key-value pairs
-   *
-   * @returns Iterator yielding [key, value] tuples
-   *
-   * @example
-   * ```typescript
-   * for (const [key, value] of kv) {
-   *   console.log(`${key}:`, value);
-   * }
-   *
-   * // Or using spread operator
-   * const entries = [...kv];
-   * ```
-   */
+       * Iterator implementation for iterating over all non-expired key-value pairs
+       *
+       * @returns Iterator yielding [key, value] tuples
+       *
+       * @example
+       * ```typescript
+       * for (const [key, value] of kv) {
+       *   console.log(`${key}:`, value);
+       * }
+       *
+       * // Or using spread operator
+       * const entries = [...kv];
+       * ```
+       */
   [Symbol.iterator](): Iterator<[string, any]>;
   /**
-   * Executes a function within a transaction
-   *
-   * @param fn - Function to execute within the transaction (can be async)
-   * @returns The result of the function
-   *
-   * @example
-   * ```typescript
-   * // Synchronous transaction
-   * kv.transaction(() => {
-   *   kv.set('user:123', { name: 'John', age: 30 });
-   *   kv.set('user:456', { name: 'Jane', age: 25 });
-   *   // If any operation fails, all changes are rolled back
-   * });
-   *
-   * // Async transaction
-   * await kv.transaction(async () => {
-   *   kv.set('user:123', { name: 'John', age: 30 });
-   *   await someAsyncOperation();
-   *   kv.set('user:456', { name: 'Jane', age: 25 });
-   *   // If any operation fails, all changes are rolled back
-   * });
-   * ```
-   */
+       * Executes a function within a transaction
+       *
+       * @param fn - Function to execute within the transaction (can be async)
+       * @returns The result of the function
+       *
+       * @example
+       * ```typescript
+       * // Synchronous transaction
+       * kv.transaction(() => {
+       *   kv.set('user:123', { name: 'John', age: 30 });
+       *   kv.set('user:456', { name: 'Jane', age: 25 });
+       *   // If any operation fails, all changes are rolled back
+       * });
+       *
+       * // Async transaction
+       * await kv.transaction(async () => {
+       *   kv.set('user:123', { name: 'John', age: 30 });
+       *   await someAsyncOperation();
+       *   kv.set('user:456', { name: 'Jane', age: 25 });
+       *   // If any operation fails, all changes are rolled back
+       * });
+       * ```
+       */
   transaction<T>(fn: () => T | Promise<T>): Promise<T>;
 }
 /**