@arcote.tech/arc 0.1.12 → 0.3.0

package/dist/context-element/view/view.d.ts

@@ -0,0 +1,194 @@
+import { ArcContextElement } from "../../context-element/context-element";
+import type { DatabaseStoreSchema } from "../../data-storage/database-store";
+import { type ArcObjectAny } from "../../elements/object";
+import type { ArcTokenAny } from "../../token/token";
+import type { TokenInstanceAny } from "../../token/token-instance";
+import type { Merge } from "../../utils";
+import type { ArcViewHandlerContext, ArcViewItem, ArcViewQueryContext } from "./view-context";
+import type { ArcViewData, ViewProtectionFn } from "./view-data";
+/**
+ * Arc View - Read-optimized projection of events
+ *
+ * Views are queryable collections built from events.
+ * They:
+ * - React to events and update their state
+ * - Provide optimized read access (find, findOne)
+ * - Can be queried by commands
+ * - Maintain denormalized data for fast reads
+ *
+ * Views follow the factory pattern from the Arc guide:
+ * - All configuration in a single Data object
+ * - Type-safe throughout
+ * - Immutable with clone-on-modify
+ *
+ * @example
+ * ```typescript
+ * const tasks = view("tasks", taskId, taskSchema)
+ *   .handleEvent(taskCreated, async (ctx, event) => {
+ *     await ctx.set(event.payload.taskId, {
+ *       title: event.payload.title,
+ *       isCompleted: false,
+ *     });
+ *   })
+ *   .handleEvent(taskCompleted, async (ctx, event) => {
+ *     await ctx.modify(event.payload.taskId, {
+ *       isCompleted: true,
+ *     });
+ *   });
+ * ```
+ */
+export declare class ArcView<const Data extends ArcViewData> extends ArcContextElement<Data["name"]> {
+    private readonly data;
+    constructor(data: Data);
+    /**
+     * Get view ID schema
+     */
+    get id(): Data["id"];
+    /**
+     * Get view schema
+     */
+    get schema(): Data["schema"];
+    /**
+     * Set view description for documentation
+     */
+    description<const Desc extends string>(description: Desc): ArcView<Merge<Data, {
+        description: Desc;
+    }>>;
+    /**
+     * Mark view as async (handlers run asynchronously)
+     */
+    async(): ArcView<Merge<Data, {
+        isAsync: true;
+    }>>;
+    /**
+     * Set view version for schema migrations
+     */
+    version<const V extends number>(version: V): ArcView<Merge<Data, {
+        version: V;
+    }>>;
+    /**
+     * Declare which events this view listens to
+     * Must be called before handle() to register event dependencies
+     *
+     * @param events - Array of events this view reacts to
+     */
+    listenTo<const Events extends ArcContextElement<any>[]>(events: Events): ArcView<Merge<Data, {
+        elements: Events;
+    }>>;
+    /**
+     * Add event handler for a specific event
+     * Handlers update view state in response to events
+     *
+     * @param event - Event to handle
+     * @param handler - Handler function that updates view state
+     */
+    handleEvent<Event extends ArcContextElement<any>>(event: Event, handler: (ctx: ArcViewHandlerContext<Data["id"], Data["schema"]>, event: any) => Promise<void>): ArcView<Merge<Data, {
+        elements: [...Data["elements"], Event];
+        handler: Data["handler"] & { [K in Event["name"]]: typeof handler; };
+    }>>;
+    /**
+     * Set all event handlers at once
+     * Alternative to chaining handleEvent() calls
+     *
+     * @param handler - Object mapping event names to handlers
+     */
+    handle<Handler extends Record<string, (ctx: any, event: any) => Promise<void>>>(handler: Handler): ArcView<Merge<Data, {
+        handler: Handler;
+    }>>;
+    /**
+     * Generate query context for this view
+     * Provides read access to view data
+     * Automatically applies token restrictions from protectBy
+     *
+     * @param adapters - Available adapters (storage, authAdapter)
+     * @returns Context object with find/findOne methods
+     */
+    queryContext(adapters: any): ArcViewQueryContext<Data["id"], Data["schema"]>;
+    /**
+     * Get event handlers for this view
+     * Used by the framework to set up event listeners
+     */
+    getHandlers(): Data["handler"];
+    /**
+     * Get elements (events) this view depends on
+     */
+    getElements(): Data["elements"];
+    /**
+     * Add token-based protection to this view
+     * Defines read/write access conditions based on token params
+     *
+     * @param token - Token definition to protect with
+     * @param protectionFn - Function returning read/write conditions
+     *
+     * @example
+     * ```typescript
+     * view("tasks", taskId, taskSchema)
+     *   .protectBy(userToken, (params) => ({
+     *     read: { userId: params.userId },  // Can only read own tasks
+     *     write: { userId: params.userId }, // Can only write own tasks
+     *   }));
+     * ```
+     */
+    protectBy<T extends ArcTokenAny>(token: T, protectionFn: ViewProtectionFn<any>): ArcView<Data>;
+    /**
+     * Check if view has protections
+     */
+    get hasProtections(): boolean;
+    /**
+     * Get all protection configurations
+     */
+    get protections(): import("./view-data").ViewProtection[];
+    /**
+     * Get protection config for a specific token instance
+     *
+     * @param tokenInstance - Token instance to get protection for
+     * @returns Protection config or null if no matching protection
+     */
+    getProtectionFor(tokenInstance: TokenInstanceAny): {
+        read: any;
+        write: any;
+    } | null;
+    /**
+     * Generate database store schema for this view
+     * Returns the view table with _id as primary key
+     */
+    databaseStoreSchema(): DatabaseStoreSchema;
+    /**
+     * Create reinitTable function for event replay
+     * This rebuilds the view by replaying all events through handlers
+     */
+    private createReinitTable;
+}
+/**
+ * Create a new view with the given name, ID schema, and data schema
+ *
+ * @param name - Unique view name (plural noun, e.g., "tasks")
+ * @param id - ID schema for view records
+ * @param schema - Data schema for view records
+ * @returns New view instance ready for configuration
+ *
+ * @example
+ * ```typescript
+ * const tasks = view("tasks", taskId, {
+ *   title: string(),
+ *   isCompleted: boolean(),
+ * });
+ * ```
+ */
+export declare function view<const Name extends string, Id, Schema extends ArcObjectAny>(name: Name, id: Id, schema: Schema): ArcView<{
+    name: Name;
+    id: Id;
+    schema: Schema;
+    elements: [];
+    handler: {};
+    protections: [];
+}>;
+/**
+ * Type alias for any view (used in collections)
+ */
+export type ArcViewAny = ArcView<any>;
+/**
+ * Helper type to extract view record type
+ */
+export type ArcViewRecord<View extends ArcViewAny> = View extends ArcView<infer Data> ? ArcViewItem<Data["id"], Data["schema"]> : never;
+//# sourceMappingURL=view.d.ts.map

package/dist/data-storage/data-storage-forked.d.ts

@@ -1,5 +1,5 @@
-import type { ReadTransaction, ReadWriteTransaction } from "../db";
 import { DataStorage } from "./data-storage.abstract";
+import type { ReadTransaction, ReadWriteTransaction } from "./database-adapter";
 import { StoreState } from "./store-state.abstract";
 export declare class ForkedDataStorage extends DataStorage {
     private master;

package/dist/data-storage/data-storage-master.d.ts

@@ -1,16 +1,12 @@
-import type { ArcContextAny } from "../context";
-import type { DatabaseAdapter, ReadTransaction, ReadWriteTransaction } from "../db";
-import type { RealTimeCommunicationAdapterFactory } from "../rtc/rtc";
 import { ForkedDataStorage } from "./data-storage-forked";
 import { DataStorage, type DataStorageChanges } from "./data-storage.abstract";
+import type { DatabaseAdapter, ReadTransaction, ReadWriteTransaction } from "./database-adapter";
 import type { StoreState } from "./store-state.abstract";
 export declare class MasterDataStorage extends DataStorage {
     private dbAdapter;
-    private arcContext;
     private stores;
-    private rtcAdapter;
     private reinitTablesExecuted;
-    constructor(dbAdapter: Promise<DatabaseAdapter> | DatabaseAdapter, rtcAdapterFactory: RealTimeCommunicationAdapterFactory, arcContext: ArcContextAny);
+    constructor(dbAdapter: Promise<DatabaseAdapter> | DatabaseAdapter);
     private executeReinitTablesOnReady;
     getReadTransaction(): Promise<ReadTransaction>;
     getReadWriteTransaction(): Promise<ReadWriteTransaction>;
@@ -28,9 +24,10 @@ export declare class MasterDataStorage extends DataStorage {
     }[][]>;
     commitChanges(changes: DataStorageChanges[]): Promise<void>;
     fork(): ForkedDataStorage;
-    sync(progressCallback: ({ store, size, }: {
-        store: string;
-        size: number;
-    }) => void): Promise<void>;
+    /**
+     * Destroy the data storage - clears all stores and destroys the database
+     * Used for logout/reset scenarios
+     */
+    destroy(): Promise<void>;
 }
 //# sourceMappingURL=data-storage-master.d.ts.map

package/dist/data-storage/data-storage-observable.d.ts

@@ -0,0 +1,61 @@
+import type { ForkedDataStorage } from "./data-storage-forked";
+import type { DataStorage, DataStorageChanges, ListenerEvent, QueryListenerCallback } from "./data-storage.abstract";
+import type { ReadTransaction, ReadWriteTransaction } from "./database-adapter";
+import type { FindOptions } from "./find-options";
+import type { StoreState } from "./store-state.abstract";
+/**
+ * Observable DataStorage - wraps a DataStorage to track queries and notify on changes
+ *
+ * Used by liveQuery to:
+ * 1. Track which queries are made through view.queryContext
+ * 2. Cache results for change resolution
+ * 3. Notify when any tracked query's results change
+ *
+ * Implements DataStorage interface (duck typing)
+ */
+export declare class ObservableDataStorage {
+    private source;
+    private onChange;
+    private trackedQueries;
+    private stores;
+    constructor(source: DataStorage, onChange: () => void);
+    getStore<Item extends {
+        _id: string;
+    }>(storeName: string): StoreState<Item>;
+    fork(): ForkedDataStorage;
+    getReadTransaction(): Promise<ReadTransaction>;
+    getReadWriteTransaction(): Promise<ReadWriteTransaction>;
+    commitChanges(changes: DataStorageChanges[]): Promise<void>;
+    /**
+     * Register a tracked query
+     */
+    trackQuery<Item extends {
+        _id: string;
+    }>(storeName: string, options: FindOptions<Item>, result: Item[], listener: QueryListenerCallback<Item>): void;
+    /**
+     * Handle change events from a store
+     * Synchronously resolves changes and notifies if any query results changed
+     */
+    handleStoreChange<Item extends {
+        _id: string;
+    }>(storeName: string, events: ListenerEvent<Item>[]): void;
+    /**
+     * Get the current cached result for a query
+     */
+    getCachedResult(storeName: string, options: FindOptions<any>): any[] | undefined;
+    /**
+     * Clear all tracked queries and unsubscribe listeners
+     */
+    clear(): void;
+    private getQueryKey;
+}
+/**
+ * Create an observable wrapper around a DataStorage that tracks queries and notifies on changes
+ * Used by liveQuery for reactivity
+ *
+ * @param dataStorage - The source DataStorage to wrap
+ * @param onChange - Called when any tracked query's results change
+ * @returns ObservableDataStorage with clear() method to unsubscribe
+ */
+export declare function observeQueries(dataStorage: DataStorage, onChange: () => void): ObservableDataStorage;
+//# sourceMappingURL=data-storage-observable.d.ts.map

package/dist/data-storage/data-storage.abstract.d.ts

@@ -1,6 +1,6 @@
 import { type Patch } from "mutative";
-import type { ReadTransaction, ReadWriteTransaction } from "../db";
 import type { ForkedDataStorage } from "./data-storage-forked";
+import type { ReadTransaction, ReadWriteTransaction } from "./database-adapter";
 import type { StoreState } from "./store-state.abstract";
 export declare abstract class DataStorage {
     abstract getStore<Item extends {

package/dist/{db/interface.d.ts → data-storage/database-adapter.d.ts}

@@ -1,5 +1,5 @@
-import type { ArcContextAny } from "../context";
-import type { FindOptions } from "../data-storage/types";
+import type { ArcContextAny } from "../";
+import type { FindOptions } from "./find-options";
 export interface ReadTransaction {
     find(store: string, options: FindOptions<any>): Promise<any[]>;
 }
@@ -12,6 +12,11 @@ export interface DatabaseAdapter {
     readWriteTransaction(stores?: string[]): ReadWriteTransaction;
     readTransaction(stores?: string[]): ReadTransaction;
     executeReinitTables(dataStorage: any): Promise<void>;
+    /**
+     * Destroy the database - drop all tables and clean up resources
+     * Used for logout/reset scenarios
+     */
+    destroy?(): Promise<void>;
 }
 export type DBAdapterFactory = (context: ArcContextAny) => Promise<DatabaseAdapter>;
-//# sourceMappingURL=interface.d.ts.map
+//# sourceMappingURL=database-adapter.d.ts.map

package/dist/{database → data-storage}/database-store.d.ts

@@ -1,6 +1,8 @@
 /**
  * Database-agnostic store data types and interfaces
  */
+import type { ArcObjectAny } from "../elements";
+import type { DataStorage } from "./data-storage.abstract";
 export type DatabaseType = "sqlite" | "postgresql" | "mysql";
 export interface DatabaseStoreData {
     /** Mark this field as primary key */
@@ -55,4 +57,47 @@ export interface DatabaseAgnosticColumnInfo {
         [key: string]: any;
     };
 }
+export type StoreColumn = {
+    name: string;
+    type: string;
+    isOptional?: boolean;
+    default?: any;
+    computed?: string | ((item: any, context: {
+        now: string;
+    }) => any);
+};
+export type StoreRelation = {
+    table: string;
+    type: "one-to-many" | "many-to-many" | "one-to-one";
+    foreignKey: string;
+    throughTable?: string;
+};
+export type StoreTable = {
+    name: string;
+    columns: StoreColumn[];
+    primaryKey: string;
+};
+export type StoreSchema = {
+    tables: StoreTable[];
+    relations?: StoreRelation[];
+};
+/**
+ * New database-agnostic schema definition
+ */
+export type DatabaseStoreTable = {
+    name: string;
+    schema: ArcObjectAny;
+    version?: number;
+    options?: {
+        /** Include soft delete columns */
+        softDelete?: boolean;
+        /** Include per-table version tracking for data syncing */
+        versioning?: boolean;
+    };
+};
+export type DatabaseStoreSchema = {
+    tables: DatabaseStoreTable[];
+    relations?: StoreRelation[];
+    reinitTable?: (tableName: string, dataStorage: DataStorage) => Promise<void>;
+};
 //# sourceMappingURL=database-store.d.ts.map

package/dist/data-storage/{types.d.ts → find-options.d.ts}

@@ -25,4 +25,4 @@ export type QueryResult<T> = {
     items: T[];
     total: number;
 };
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=find-options.d.ts.map

package/dist/data-storage/index.d.ts

@@ -1,9 +1,13 @@
 export * from "./data-storage-forked";
 export * from "./data-storage-master";
+export * from "./data-storage-observable";
 export * from "./data-storage.abstract";
-export * from "./deep-merge";
+export * from "./database-adapter";
+export * from "./database-store";
+export * from "./find-options";
+export * from "./query-result-resolver";
+export * from "./schema-extraction";
 export * from "./store-state-fork";
 export * from "./store-state-master";
 export * from "./store-state.abstract";
-export type * from "./types";
 //# sourceMappingURL=index.d.ts.map

package/dist/{db/postgresAdapter.d.ts → data-storage/postgresql-adapter.d.ts}

@@ -1,7 +1,7 @@
-import { type ArcContextAny } from "../context";
-import type { StoreColumn, StoreTable } from "../context/element";
-import type { FindOptions, WhereCondition } from "../data-storage/types";
-import type { DatabaseAdapter, DBAdapterFactory, ReadTransaction, ReadWriteTransaction } from "./interface";
+import type { ArcContextAny } from "../context";
+import type { DatabaseAdapter, DBAdapterFactory, ReadTransaction, ReadWriteTransaction } from "./database-adapter";
+import type { StoreColumn, StoreTable } from "./database-store";
+import type { FindOptions, WhereCondition } from "./find-options";
 export interface PostgreSQLDatabase {
     exec(sql: string, params?: any[]): Promise<any>;
     execBatch(queries: Array<{
@@ -17,7 +17,6 @@ declare class PostgreSQLReadTransaction implements ReadTransaction {
     protected hasSoftDelete(tableName: string): boolean;
     protected deserializeValue(value: any, column: StoreColumn): any;
     protected deserializeRow(row: any, table: StoreTable): any;
-    protected getId(store: string, id: any): any;
     protected buildWhereClause(where?: WhereCondition, tableName?: string): {
         sql: string;
         params: any[];
@@ -41,7 +40,6 @@ export declare class PostgreSQLAdapter implements DatabaseAdapter {
     private db;
     private context;
     private tables;
-    private tableSchemas;
     private pendingReinitTables;
     private mapType;
     private buildConstraints;
@@ -50,41 +48,17 @@ export declare class PostgreSQLAdapter implements DatabaseAdapter {
     constructor(db: PostgreSQLDatabase, context: ArcContextAny);
     initialize(): Promise<void>;
     private createTableIfNotExistsNew;
-    /**
-     * Create the version counter table for tracking per-table version sequences
-     */
     private createVersionCounterTable;
-    /**
-     * Create the table versions tracking table for schema versioning
-     */
     private createTableVersionsTable;
-    /**
-     * Generate physical table name with version suffix
-     */
     private getPhysicalTableName;
-    /**
-     * Check if a versioned table exists
-     */
     private checkVersionedTableExists;
-    /**
-     * Register a new table version
-     */
     private registerTableVersion;
-    /**
-     * Check if a table has versioning enabled
-     */
     hasVersioning(tableName: string): boolean;
-    /**
-     * Check if a table has soft delete enabled
-     */
     hasSoftDelete(tableName: string): boolean;
-    /**
-     * Execute all pending reinitTable functions
-     */
     executeReinitTables(dataStorage: any): Promise<void>;
-    readWriteTransaction(stores?: string[]): PostgreSQLReadWriteTransaction;
-    readTransaction(stores?: string[]): PostgreSQLReadTransaction;
+    readWriteTransaction(_stores?: string[]): PostgreSQLReadWriteTransaction;
+    readTransaction(_stores?: string[]): PostgreSQLReadTransaction;
 }
 export declare const createPostgreSQLAdapterFactory: (db: PostgreSQLDatabase) => DBAdapterFactory;
 export {};
-//# sourceMappingURL=postgresAdapter.d.ts.map
+//# sourceMappingURL=postgresql-adapter.d.ts.map

package/dist/data-storage/query-result-resolver.d.ts

@@ -0,0 +1,18 @@
+import type { ListenerEvent } from "./data-storage.abstract";
+import type { FindOptions } from "./find-options";
+/**
+ * Resolves a change event against a cached query result
+ * Returns the new result array or false if unchanged
+ */
+export declare function resolveQueryChange<Item extends {
+    _id: string;
+}>(currentResult: Item[], event: ListenerEvent<Item>, options: FindOptions<Item>): Item[] | false;
+/**
+ * Check if an item matches the where clause
+ */
+export declare function checkItemMatchesWhere<Item>(item: Item, where?: Record<string, any>): boolean;
+/**
+ * Apply orderBy and limit to a result array
+ */
+export declare function applyOrderByAndLimit<Item>(result: Item[], options: FindOptions<Item>): Item[];
+//# sourceMappingURL=query-result-resolver.d.ts.map

package/dist/data-storage/query-result-resolver.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=query-result-resolver.test.d.ts.map

package/dist/{db/sqliteAdapter.d.ts → data-storage/sqlite-adapter.d.ts}

@@ -1,7 +1,7 @@
-import { type ArcContextAny } from "../context";
-import type { StoreColumn, StoreTable } from "../context/element";
-import type { FindOptions, WhereCondition } from "../data-storage/types";
-import type { DatabaseAdapter, DBAdapterFactory, ReadTransaction, ReadWriteTransaction } from "./interface";
+import type { ArcContextAny } from "../context";
+import type { DatabaseAdapter, DBAdapterFactory, ReadTransaction, ReadWriteTransaction } from "./database-adapter";
+import type { StoreColumn, StoreTable } from "./database-store";
+import type { FindOptions, WhereCondition } from "./find-options";
 export interface SQLiteDatabase {
     exec(sql: string, params?: any[]): Promise<any>;
 }
@@ -13,7 +13,6 @@ declare class SQLiteReadTransaction implements ReadTransaction {
     protected hasSoftDelete(tableName: string): boolean;
     protected deserializeValue(value: any, column: StoreColumn): any;
     protected deserializeRow(row: any, table: StoreTable): any;
-    protected getId(store: string, id: any): any;
     protected buildWhereClause(where?: WhereCondition, tableName?: string): {
         sql: string;
         params: any[];
@@ -36,7 +35,6 @@ export declare class SQLiteAdapter implements DatabaseAdapter {
     private db;
     private context;
     private tables;
-    private tableSchemas;
     private pendingReinitTables;
     private mapType;
     private buildConstraints;
@@ -45,41 +43,17 @@ export declare class SQLiteAdapter implements DatabaseAdapter {
     constructor(db: SQLiteDatabase, context: ArcContextAny);
     initialize(): Promise<void>;
     private createTableIfNotExistsNew;
-    /**
-     * Create the version counter table for tracking per-table version sequences
-     */
     private createVersionCounterTable;
-    /**
-     * Create the table versions tracking table for schema versioning
-     */
     private createTableVersionsTable;
-    /**
-     * Generate physical table name with version suffix
-     */
     private getPhysicalTableName;
-    /**
-     * Check if a versioned table exists
-     */
     private checkVersionedTableExists;
-    /**
-     * Register a new table version
-     */
     private registerTableVersion;
-    /**
-     * Check if a table has versioning enabled
-     */
     hasVersioning(tableName: string): boolean;
-    /**
-     * Check if a table has soft delete enabled
-     */
     hasSoftDelete(tableName: string): boolean;
-    /**
-     * Execute all pending reinitTable functions
-     */
     executeReinitTables(dataStorage: any): Promise<void>;
     readWriteTransaction(stores?: string[]): SQLiteReadWriteTransaction;
     readTransaction(stores?: string[]): SQLiteReadTransaction;
 }
 export declare const createSQLiteAdapterFactory: (db: SQLiteDatabase) => DBAdapterFactory;
 export {};
-//# sourceMappingURL=sqliteAdapter.d.ts.map
+//# sourceMappingURL=sqlite-adapter.d.ts.map

package/dist/data-storage/store-state-fork.d.ts

@@ -1,6 +1,6 @@
 import type { DataStorage, ListenerEvent, QueryListenerCallback, StoreStateChange } from "./data-storage.abstract";
 import { StoreState } from "./store-state.abstract";
-import type { FindOptions } from "./types";
+import type { FindOptions } from "./find-options";
 export declare class ForkedStoreState<Item extends {
     _id: string;
 }> extends StoreState<Item> {

package/dist/data-storage/store-state-master.d.ts

@@ -1,7 +1,7 @@
-import type { ReadWriteTransaction } from "../db";
 import type { DataStorage, ListenerEvent, QueryListenerCallback, StoreStateChange } from "./data-storage.abstract";
+import type { ReadWriteTransaction } from "./database-adapter";
+import type { FindOptions } from "./find-options";
 import { StoreState } from "./store-state.abstract";
-import type { FindOptions } from "./types";
 export declare class MasterStoreState<Item extends {
     _id: string;
 }> extends StoreState<Item> {
@@ -17,5 +17,9 @@ export declare class MasterStoreState<Item extends {
     }>;
     applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
     find(options: FindOptions<Item>, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
+    /**
+     * Public method to notify listeners (used by MasterDataStorage.commitChanges)
+     */
+    notifyListenersPublic(events: ListenerEvent<Item>[]): void;
 }
 //# sourceMappingURL=store-state-master.d.ts.map

package/dist/data-storage/store-state.abstract.d.ts

@@ -1,6 +1,6 @@
 import type { DataStorage, ListenerEvent, QueryListener, QueryListenerCallback, StoreStateChange } from "./data-storage.abstract";
 import { ForkedStoreState } from "./store-state-fork";
-import type { FindOptions } from "./types";
+import type { FindOptions } from "./find-options";
 export declare abstract class StoreState<Item extends {
     _id: string;
 }> {

package/dist/elements/abstract.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseAgnosticColumnInfo, DatabaseStoreData } from "../database/database-store";
+import type { DatabaseAgnosticColumnInfo, DatabaseStoreData } from "../data-storage/database-store";
 import { ArcBranded } from "./branded";
 import { ArcDefault } from "./default";
 import type { ArcElement } from "./element";

package/dist/elements/any.d.ts

@@ -1,5 +1,5 @@
 import { ArcAbstract, type Validators } from "./abstract";
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
+import type { DatabaseAgnosticColumnInfo } from "../data-storage/database-store";
 export declare class ArcAny<T, V extends Validators = []> extends ArcAbstract<V> {
     constructor();
     parse(value: T): any;

package/dist/elements/array.d.ts

@@ -1,7 +1,7 @@
-import { type util } from "../utils";
+import type { FirstArgument } from "../utils/types/first-argument";
 import { ArcAbstract, type CheckFn, type GetValidator, type Validators } from "./abstract";
 import type { ArcElement } from "./element";
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
+import type { DatabaseAgnosticColumnInfo } from "../data-storage/database-store";
 declare const arrayValidator: {
     name: "type";
     validator: (value: any) => false | {
@@ -47,9 +47,9 @@ export declare class ArcArray<E extends ArcElement, V extends Validators = [
             readonly msg: "array is empty";
         } | undefined;
     }]>;
-    parse(value: util.FirstArgument<E["deserialize"]>[]): ReturnType<E["parse"]>[];
-    serialize(value: util.FirstArgument<E["serialize"]>[]): ReturnType<E["serialize"]>[];
-    deserialize(value: util.FirstArgument<E["deserialize"]>[]): ReturnType<E["deserialize"]>[];
+    parse(value: FirstArgument<E["deserialize"]>[]): ReturnType<E["parse"]>[];
+    serialize(value: FirstArgument<E["serialize"]>[]): ReturnType<E["serialize"]>[];
+    deserialize(value: FirstArgument<E["deserialize"]>[]): ReturnType<E["deserialize"]>[];
     deserializePath(path: string[], value: any): any;
     validation<Name extends string, Fn extends CheckFn<any>>(name: Name, validator: Fn): ArcArray<E, GetValidator<ArcAbstract<[...V, {
         name: Name;

package/dist/elements/blob.d.ts

@@ -1,6 +1,6 @@
 import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
+import type { DatabaseAgnosticColumnInfo } from "../data-storage/database-store";
 declare const blobValidator: {
     readonly name: "blob";
     readonly validator: (value: any) => {