@dexto/storage 1.6.0 → 1.6.2

package/dist/cache/factories/redis.d.cts

@@ -1,24 +0,0 @@
-import { RedisCacheConfig } from '../schemas.cjs';
-import { CacheFactory } from '../factory.cjs';
-import 'zod';
-import '@dexto/core';
-
-/**
- * Factory for Redis cache storage.
- *
- * This factory stores data in a Redis server using the ioredis package.
- * It's ideal for production deployments requiring scalability, persistence,
- * and multi-machine access.
- *
- * Features:
- * - Native TTL support
- * - Connection pooling
- * - Pub/sub capabilities (via additional methods)
- * - Suitable for distributed deployments
- *
- * Note: ioredis is an optional dependency. Install it with:
- * npm install ioredis
- */
-declare const redisCacheFactory: CacheFactory<RedisCacheConfig>;
-
-export { redisCacheFactory };

package/dist/cache/factory.d.cts

@@ -1,42 +0,0 @@
-import { Logger, Cache } from '@dexto/core';
-import { z } from 'zod';
-
-/**
- * Factory interface for creating cache instances.
- *
- * Factories are plain exports (no global registries). Images decide which factories are
- * available by including them in `image.storage.cache`.
- */
-interface CacheFactory<TConfig = unknown> {
-    /**
-     * Zod schema for validating factory-specific configuration.
-     * The schema must output the `TConfig` type.
-     */
-    configSchema: z.ZodType<TConfig, z.ZodTypeDef, unknown>;
-    /**
-     * Factory function to create a Cache instance.
-     *
-     * Cache factories may return a Promise to support lazy loading of optional
-     * dependencies (e.g., `ioredis`).
-     *
-     * @param config - Validated configuration specific to this backend
-     * @param logger - Logger instance for the cache
-     * @returns A Cache implementation (or Promise for async backends)
-     */
-    create(config: TConfig, logger: Logger): Cache | Promise<Cache>;
-    /**
-     * Optional metadata for documentation, UIs, and discovery.
-     */
-    metadata?: {
-        /** Human-readable name (e.g., "Redis", "Memcached") */
-        displayName: string;
-        /** Brief description of this cache backend */
-        description: string;
-        /** Whether this backend requires network connectivity */
-        requiresNetwork?: boolean;
-        /** Whether this backend supports TTL (time-to-live) */
-        supportsTTL?: boolean;
-    };
-}
-
-export type { CacheFactory };

package/dist/cache/index.d.cts

@@ -1,7 +0,0 @@
-export { CacheFactory } from './factory.cjs';
-export { Cache } from '@dexto/core';
-export { inMemoryCacheFactory } from './factories/memory.cjs';
-export { redisCacheFactory } from './factories/redis.cjs';
-export { CACHE_TYPES, CacheConfig, CacheConfigSchema, CacheType, InMemoryCacheConfig, InMemoryCacheSchema, RedisCacheConfig, RedisCacheSchema } from './schemas.cjs';
-export { MemoryCacheStore } from './memory-cache-store.cjs';
-import 'zod';

package/dist/cache/memory-cache-store.d.cts

@@ -1,27 +0,0 @@
-import { Cache } from '@dexto/core';
-
-/**
- * In-memory cache store for development and testing.
- * Supports TTL for automatic cleanup of temporary data.
- * Data is lost when the process restarts.
- */
-declare class MemoryCacheStore implements Cache {
-    private data;
-    private ttls;
-    private connected;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getStoreType(): string;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-    delete(key: string): Promise<void>;
-    private checkConnection;
-    private checkTTL;
-    clear(): Promise<void>;
-    dump(): Promise<{
-        data: Record<string, unknown>;
-    }>;
-}
-
-export { MemoryCacheStore };

package/dist/cache/redis-store.d.cts

@@ -1,34 +0,0 @@
-import { Cache, Logger } from '@dexto/core';
-import { RedisCacheConfig } from './schemas.cjs';
-import 'zod';
-
-/**
- * Redis cache store for production cache operations.
- * Implements the Cache interface with connection pooling and optimizations.
- * EXPERIMENTAL - NOT FULLY TESTED YET
- */
-declare class RedisStore implements Cache {
-    private config;
-    private redis;
-    private connected;
-    private logger;
-    constructor(config: RedisCacheConfig, logger: Logger);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getStoreType(): string;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
-    delete(key: string): Promise<void>;
-    mget<T>(keys: string[]): Promise<(T | undefined)[]>;
-    mset<T>(entries: [string, T][]): Promise<void>;
-    exists(key: string): Promise<boolean>;
-    expire(key: string, ttlSeconds: number): Promise<void>;
-    increment(key: string, by?: number): Promise<number>;
-    decrement(key: string, by?: number): Promise<number>;
-    private checkConnection;
-    flushdb(): Promise<void>;
-    info(): Promise<string>;
-}
-
-export { RedisStore };

package/dist/cache/schemas.d.cts

@@ -1,93 +0,0 @@
-import { z } from 'zod';
-
-declare const CACHE_TYPES: readonly ["in-memory", "redis"];
-type CacheType = (typeof CACHE_TYPES)[number];
-declare const InMemoryCacheSchema: z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-} & {
-    type: z.ZodLiteral<"in-memory">;
-}, "strict", z.ZodTypeAny, {
-    type: "in-memory";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-}, {
-    type: "in-memory";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-}>;
-type InMemoryCacheConfig = z.output<typeof InMemoryCacheSchema>;
-declare const RedisCacheSchema: z.ZodEffects<z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-} & {
-    type: z.ZodLiteral<"redis">;
-    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    host: z.ZodOptional<z.ZodString>;
-    port: z.ZodOptional<z.ZodNumber>;
-    password: z.ZodOptional<z.ZodString>;
-    database: z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    type: "redis";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-    url?: string | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    password?: string | undefined;
-    database?: number | undefined;
-}, {
-    type: "redis";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-    url?: string | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    password?: string | undefined;
-    database?: number | undefined;
-}>, {
-    type: "redis";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-    url?: string | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    password?: string | undefined;
-    database?: number | undefined;
-}, {
-    type: "redis";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-    url?: string | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    password?: string | undefined;
-    database?: number | undefined;
-}>;
-type RedisCacheConfig = z.output<typeof RedisCacheSchema>;
-declare const CacheConfigSchema: z.ZodObject<{
-    type: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    type: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    type: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>;
-type CacheConfig = z.output<typeof CacheConfigSchema>;
-
-export { CACHE_TYPES, type CacheConfig, CacheConfigSchema, type CacheType, type InMemoryCacheConfig, InMemoryCacheSchema, type RedisCacheConfig, RedisCacheSchema };

package/dist/cache/types.d.cts

@@ -1 +0,0 @@
-export { Cache } from '@dexto/core';

package/dist/database/factories/index.d.cts

@@ -1,7 +0,0 @@
-export { inMemoryDatabaseFactory } from './memory.cjs';
-export { sqliteDatabaseFactory } from './sqlite.cjs';
-export { postgresDatabaseFactory } from './postgres.cjs';
-import '../schemas.cjs';
-import 'zod';
-import '../factory.cjs';
-import '@dexto/core';

package/dist/database/factories/memory.d.cts

@@ -1,20 +0,0 @@
-import { InMemoryDatabaseConfig } from '../schemas.cjs';
-import { DatabaseFactory } from '../factory.cjs';
-import 'zod';
-import '@dexto/core';
-
-/**
- * Factory for in-memory database storage.
- *
- * This factory stores data in RAM and is ideal for development,
- * testing, and ephemeral use cases where persistence is not required.
- *
- * Features:
- * - Zero external dependencies
- * - Fast in-memory operations
- * - No network required
- * - Data is lost on restart
- */
-declare const inMemoryDatabaseFactory: DatabaseFactory<InMemoryDatabaseConfig>;
-
-export { inMemoryDatabaseFactory };

package/dist/database/factories/postgres.d.cts

@@ -1,23 +0,0 @@
-import { PostgresDatabaseConfig } from '../schemas.cjs';
-import { DatabaseFactory } from '../factory.cjs';
-import 'zod';
-import '@dexto/core';
-
-/**
- * Factory for PostgreSQL database storage.
- *
- * This factory stores data in a PostgreSQL database server using the pg package.
- * It's ideal for production deployments requiring scalability and multi-machine access.
- *
- * Features:
- * - Connection pooling for efficient resource usage
- * - JSONB storage for flexible data types
- * - Transaction support
- * - Suitable for distributed deployments
- *
- * Note: pg is an optional dependency. Install it with:
- * npm install pg
- */
-declare const postgresDatabaseFactory: DatabaseFactory<PostgresDatabaseConfig>;
-
-export { postgresDatabaseFactory };

package/dist/database/factories/sqlite.d.cts

@@ -1,24 +0,0 @@
-import { SqliteDatabaseConfig } from '../schemas.cjs';
-import { DatabaseFactory } from '../factory.cjs';
-import 'zod';
-import '@dexto/core';
-
-/**
- * Factory for SQLite database storage.
- *
- * This factory stores data in a local SQLite database file using better-sqlite3.
- * It's ideal for single-machine deployments and development scenarios where
- * persistence is required without the overhead of a database server.
- *
- * Features:
- * - Uses better-sqlite3 for synchronous, fast operations
- * - WAL mode enabled for better concurrency
- * - No external server required
- * - Persistent storage survives restarts
- *
- * Note: better-sqlite3 is an optional dependency. Install it with:
- * npm install better-sqlite3
- */
-declare const sqliteDatabaseFactory: DatabaseFactory<SqliteDatabaseConfig>;
-
-export { sqliteDatabaseFactory };

package/dist/database/factory.d.cts

@@ -1,42 +0,0 @@
-import { Logger, Database } from '@dexto/core';
-import { z } from 'zod';
-
-/**
- * Factory interface for creating database instances.
- *
- * Factories are plain exports (no global registries). Images decide which factories are
- * available by including them in `image.storage.database`.
- */
-interface DatabaseFactory<TConfig = unknown> {
-    /**
-     * Zod schema for validating factory-specific configuration.
-     * The schema must output the `TConfig` type.
-     */
-    configSchema: z.ZodType<TConfig, z.ZodTypeDef, unknown>;
-    /**
-     * Factory function to create a Database instance.
-     *
-     * Database factories may return a Promise to support lazy loading of optional
-     * dependencies (e.g., `better-sqlite3`, `pg`).
-     *
-     * @param config - Validated configuration specific to this backend
-     * @param logger - Logger instance for the database
-     * @returns A Database implementation (or Promise for async backends)
-     */
-    create(config: TConfig, logger: Logger): Database | Promise<Database>;
-    /**
-     * Optional metadata for documentation, UIs, and discovery.
-     */
-    metadata?: {
-        /** Human-readable name (e.g., "SQLite", "PostgreSQL") */
-        displayName: string;
-        /** Brief description of this storage backend */
-        description: string;
-        /** Whether this backend requires network connectivity */
-        requiresNetwork?: boolean;
-        /** Whether this backend supports list operations (append/getRange) */
-        supportsListOperations?: boolean;
-    };
-}
-
-export type { DatabaseFactory };

package/dist/database/index.d.cts

@@ -1,8 +0,0 @@
-export { DatabaseFactory } from './factory.cjs';
-export { Database } from '@dexto/core';
-export { inMemoryDatabaseFactory } from './factories/memory.cjs';
-export { sqliteDatabaseFactory } from './factories/sqlite.cjs';
-export { postgresDatabaseFactory } from './factories/postgres.cjs';
-export { DATABASE_TYPES, DatabaseConfig, DatabaseConfigSchema, DatabaseType, InMemoryDatabaseConfig, InMemoryDatabaseSchema, PostgresDatabaseConfig, PostgresDatabaseSchema, SqliteDatabaseConfig, SqliteDatabaseSchema } from './schemas.cjs';
-export { MemoryDatabaseStore } from './memory-database-store.cjs';
-import 'zod';

package/dist/database/memory-database-store.d.cts

@@ -1,30 +0,0 @@
-import { Database } from '@dexto/core';
-
-/**
- * In-memory database store for development and testing.
- * Supports list operations for message history and enumeration for settings.
- * Data is lost when the process restarts.
- */
-declare class MemoryDatabaseStore implements Database {
-    private data;
-    private lists;
-    private connected;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getStoreType(): string;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T): Promise<void>;
-    delete(key: string): Promise<void>;
-    list(prefix: string): Promise<string[]>;
-    append<T>(key: string, item: T): Promise<void>;
-    getRange<T>(key: string, start: number, count: number): Promise<T[]>;
-    private checkConnection;
-    clear(): Promise<void>;
-    dump(): Promise<{
-        data: Record<string, unknown>;
-        lists: Record<string, unknown[]>;
-    }>;
-}
-
-export { MemoryDatabaseStore };

package/dist/database/postgres-store.d.cts

@@ -1,57 +0,0 @@
-import { PoolClient } from 'pg';
-import { Database, Logger } from '@dexto/core';
-import { PostgresDatabaseConfig } from './schemas.cjs';
-import 'zod';
-
-/**
- * PostgreSQL database store for production database operations.
- * Implements the Database interface with connection pooling and JSONB support.
- * EXPERIMENTAL - NOT FULLY TESTED YET
- */
-declare class PostgresStore implements Database {
-    private config;
-    private pool;
-    private connected;
-    private logger;
-    constructor(config: PostgresDatabaseConfig, logger: Logger);
-    connect(): Promise<void>;
-    /**
-     * Creates a PostgreSQL schema if it doesn't exist.
-     */
-    private createSchema;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getStoreType(): string;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T): Promise<void>;
-    delete(key: string): Promise<void>;
-    list(prefix: string): Promise<string[]>;
-    append<T>(key: string, item: T): Promise<void>;
-    getRange<T>(key: string, start: number, count: number): Promise<T[]>;
-    private createTables;
-    private checkConnection;
-    /**
-     * Check if an error is a connection error that should trigger a retry.
-     * Common with serverless databases (Neon) where connections go stale.
-     */
-    private isConnectionError;
-    /**
-     * Execute a database operation with automatic retry on connection errors.
-     * Handles serverless DB connection issues (Neon cold starts, stale connections).
-     */
-    private withRetry;
-    /**
-     * Execute a callback within a database transaction.
-     * Note: On connection failure, the entire callback will be retried on a new connection.
-     * Ensure callback operations are idempotent or use this only for read operations.
-     */
-    transaction<T>(callback: (client: PoolClient) => Promise<T>): Promise<T>;
-    getStats(): Promise<{
-        kvCount: number;
-        listCount: number;
-        totalSize: string;
-    }>;
-    vacuum(): Promise<void>;
-}
-
-export { PostgresStore };

package/dist/database/schemas.d.cts

@@ -1,127 +0,0 @@
-import { z } from 'zod';
-
-declare const DATABASE_TYPES: readonly ["in-memory", "sqlite", "postgres"];
-type DatabaseType = (typeof DATABASE_TYPES)[number];
-declare const InMemoryDatabaseSchema: z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-} & {
-    type: z.ZodLiteral<"in-memory">;
-}, "strict", z.ZodTypeAny, {
-    type: "in-memory";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-}, {
-    type: "in-memory";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-}>;
-type InMemoryDatabaseConfig = z.output<typeof InMemoryDatabaseSchema>;
-declare const SqliteDatabaseSchema: z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-} & {
-    type: z.ZodLiteral<"sqlite">;
-    path: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    path: string;
-    type: "sqlite";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-}, {
-    path: string;
-    type: "sqlite";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-}>;
-type SqliteDatabaseConfig = z.output<typeof SqliteDatabaseSchema>;
-declare const PostgresDatabaseSchema: z.ZodEffects<z.ZodObject<{
-    maxConnections: z.ZodOptional<z.ZodNumber>;
-    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-} & {
-    type: z.ZodLiteral<"postgres">;
-    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    connectionString: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    host: z.ZodOptional<z.ZodString>;
-    port: z.ZodOptional<z.ZodNumber>;
-    database: z.ZodOptional<z.ZodString>;
-    password: z.ZodOptional<z.ZodString>;
-    keyPrefix: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    type: "postgres";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-    url?: string | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    password?: string | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    keyPrefix?: string | undefined;
-}, {
-    type: "postgres";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-    url?: string | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    password?: string | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    keyPrefix?: string | undefined;
-}>, {
-    type: "postgres";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-    url?: string | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    password?: string | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    keyPrefix?: string | undefined;
-}, {
-    type: "postgres";
-    maxConnections?: number | undefined;
-    idleTimeoutMillis?: number | undefined;
-    connectionTimeoutMillis?: number | undefined;
-    options?: Record<string, unknown> | undefined;
-    url?: string | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    password?: string | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    keyPrefix?: string | undefined;
-}>;
-type PostgresDatabaseConfig = z.output<typeof PostgresDatabaseSchema>;
-declare const DatabaseConfigSchema: z.ZodObject<{
-    type: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    type: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    type: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>;
-type DatabaseConfig = z.output<typeof DatabaseConfigSchema>;
-
-export { DATABASE_TYPES, type DatabaseConfig, DatabaseConfigSchema, type DatabaseType, type InMemoryDatabaseConfig, InMemoryDatabaseSchema, type PostgresDatabaseConfig, PostgresDatabaseSchema, type SqliteDatabaseConfig, SqliteDatabaseSchema };

package/dist/database/sqlite-store.d.cts

@@ -1,35 +0,0 @@
-import { Database, Logger } from '@dexto/core';
-import { SqliteDatabaseConfig } from './schemas.cjs';
-import 'zod';
-
-/**
- * SQLite database store for local development and production.
- * Implements the Database interface with proper schema and connection handling.
- */
-declare class SQLiteStore implements Database {
-    private db;
-    private dbPath;
-    private config;
-    private logger;
-    constructor(config: SqliteDatabaseConfig, logger: Logger);
-    private initializeTables;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getStoreType(): string;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T): Promise<void>;
-    delete(key: string): Promise<void>;
-    list(prefix: string): Promise<string[]>;
-    append<T>(key: string, item: T): Promise<void>;
-    getRange<T>(key: string, start: number, count: number): Promise<T[]>;
-    private checkConnection;
-    vacuum(): Promise<void>;
-    getStats(): Promise<{
-        kvCount: number;
-        listCount: number;
-        dbSize: number;
-    }>;
-}
-
-export { SQLiteStore };

package/dist/database/types.d.cts

@@ -1 +0,0 @@
-export { Database } from '@dexto/core';