@arcote.tech/arc 0.1.12 → 0.3.0

package/dist/token/token.d.ts

@@ -0,0 +1,127 @@
+/**
+ * ArcToken - Security context abstraction
+ *
+ * Tokens carry identity/authorization information across all layers:
+ * - React hooks (useCommands)
+ * - Commands (protectBy)
+ * - Views/Events (protectBy)
+ * - DataStorage (secure)
+ * - Wire (JWT)
+ *
+ * @example
+ * ```typescript
+ * const moderatorToken = token("moderator", { userId })
+ *   .secret(process.env.MODERATOR_SECRET)
+ *   .query([moderatorsView])
+ *   .withRules({
+ *     'form:edit': async (ctx, params) => {
+ *       return !!await ctx.moderators.findOne({ userId: params.userId });
+ *     },
+ *   });
+ * ```
+ */
+import type { ArcContextElement } from "../context-element/context-element";
+import { ArcObject, type ArcRawShape } from "../elements/object";
+import type { ModelAdapters } from "../model/model-adapters";
+import type { $type } from "../utils/types/get-type";
+import type { ArcTokenData, TokenRules } from "./token-data";
+import { TokenInstance } from "./token-instance";
+export declare class ArcToken<const Name extends string, const ParamsShape extends ArcRawShape, const QueryElements extends ArcContextElement<any>[], const Rules extends TokenRules<$type<ArcObject<ParamsShape>>, QueryElements>> {
+    private readonly data;
+    constructor(data: ArcTokenData<Name, ParamsShape, QueryElements, Rules>);
+    /**
+     * Get token name
+     */
+    get name(): Name;
+    /**
+     * Get params schema
+     */
+    get paramsSchema(): ArcObject<ParamsShape>;
+    /**
+     * Set JWT secret for this token
+     * Required for getJWT() and parseJWT()
+     *
+     * @param secret - Secret key for JWT signing/verification
+     */
+    secret<const Secret extends string | false | undefined>(secret: Secret): ArcToken<Name, ParamsShape, QueryElements, Rules>;
+    /**
+     * Add query elements needed for permission checks
+     * These views will be available in rule functions
+     *
+     * @param elements - Array of view elements to query
+     */
+    query<const Elements extends ArcContextElement<any>[]>(elements: Elements): ArcToken<Name, ParamsShape, Elements, any>;
+    /**
+     * Define permission rules for this token
+     * Rules are async functions that check if permission is granted
+     *
+     * @param rules - Map of permission names to rule functions
+     *
+     * @example
+     * ```typescript
+     * .withRules({
+     *   'form:edit': async (ctx, params) => {
+     *     const user = await ctx.users.findOne({ id: params.userId });
+     *     return user?.role === 'moderator';
+     *   },
+     * })
+     * ```
+     */
+    withRules<const NewRules extends TokenRules<$type<ArcObject<ParamsShape>>, QueryElements>>(rules: NewRules): ArcToken<Name, ParamsShape, QueryElements, NewRules>;
+    /**
+     * Create a token instance with actual parameter values
+     *
+     * @param params - Parameter values for this token instance
+     * @param adapters - Optional adapters for permission checks
+     */
+    create(params: $type<ArcObject<ParamsShape>>, adapters?: ModelAdapters): TokenInstance<$type<ArcObject<ParamsShape>>, keyof Rules & string>;
+    /**
+     * Parse JWT string to create token instance
+     *
+     * @param jwt - JWT string to parse
+     * @param adapters - Optional adapters for permission checks
+     * @returns TokenInstance or null if invalid
+     */
+    parseJWT(jwt: string, adapters?: ModelAdapters): TokenInstance<$type<ArcObject<ParamsShape>>, keyof Rules & string> | null;
+    /**
+     * Generate JWT string from params
+     * Used internally by TokenInstance.getJWT()
+     */
+    generateJWT(params: $type<ArcObject<ParamsShape>>, expiresIn?: number): string;
+    /**
+     * Check permission for given params
+     * Used internally by TokenInstance.canI()
+     */
+    checkPermission(permission: string, params: $type<ArcObject<ParamsShape>>, adapters?: ModelAdapters): Promise<boolean>;
+    /**
+     * Build rule context from query elements
+     */
+    private buildRuleContext;
+    /**
+     * Simple HMAC-like signature (for demo purposes)
+     * In production, use a proper crypto library
+     */
+    private sign;
+}
+/**
+ * Create a new token definition
+ *
+ * @param name - Unique token name
+ * @param paramsSchema - Schema defining token parameters
+ *
+ * @example
+ * ```typescript
+ * const userToken = token("user", { userId: string() })
+ *   .secret(process.env.USER_TOKEN_SECRET)
+ *   .query([usersView])
+ *   .withRules({
+ *     'profile:edit': async (ctx, params) => true,
+ *   });
+ * ```
+ */
+export declare function token<const Name extends string, const ParamsShape extends ArcRawShape>(name: Name, paramsSchema: ParamsShape): ArcToken<Name, ParamsShape, [], {}>;
+/**
+ * Type alias for any token (used in collections)
+ */
+export type ArcTokenAny = ArcToken<any, any, any, any>;
+//# sourceMappingURL=token.d.ts.map

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./deep-merge";
+export * from "./murmur-hash";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/types/add-question-marks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Add question marks to optional properties
+ */
+export type AddQuestionMarks<T> = {
+    [K in keyof T as undefined extends T[K] ? K : never]?: T[K];
+} & {
+    [K in keyof T as undefined extends T[K] ? never : K]: T[K];
+};
+//# sourceMappingURL=add-question-marks.d.ts.map

package/dist/utils/types/first-argument.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Extract the first argument type from a function
+ */
+export type FirstArgument<T extends (...args: any) => any> = T extends (arg: infer A, ...args: any) => any ? A : never;
+//# sourceMappingURL=first-argument.d.ts.map

package/dist/utils/types/get-type.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Extract the deserialized type from an element
+ */
+export type GetType<E extends {
+    deserialize: (...args: any) => any;
+}> = ReturnType<E["deserialize"]>;
+/**
+ * Alias for GetType - matches arc-old naming convention
+ */
+export type $type<E extends {
+    deserialize: (...args: any) => any;
+}> = GetType<E>;
+//# sourceMappingURL=get-type.d.ts.map

package/dist/utils/types/index.d.ts

@@ -0,0 +1,6 @@
+export type { Merge } from "./merge";
+export type { FirstArgument } from "./first-argument";
+export type { GetType, $type } from "./get-type";
+export type { AddQuestionMarks } from "./add-question-marks";
+export type { Simplify } from "./simplify";
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/types/merge.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Merge two types, with properties from B overriding properties from A
+ */
+export type Merge<A, B> = {
+    [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;
+} & {};
+//# sourceMappingURL=merge.d.ts.map

package/dist/utils/types/object-util.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Object utility types - re-exports for namespace usage
+ */
+export type { AddQuestionMarks } from "./add-question-marks";
+export type { Simplify as simplify } from "./simplify";
+//# sourceMappingURL=object-util.d.ts.map

package/dist/utils/types/simplify.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Simplify a type for better readability in IDE
+ */
+export type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+//# sourceMappingURL=simplify.d.ts.map

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.1.12",
+  "version": "0.3.0",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
-  "description": "Arc is a framework designed to align code closely with business logic, streamlining development and enhancing productivity.",
+  "description": "Arc framework core rewrite with improved event emission and type safety",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -16,10 +16,12 @@
     }
   },
   "scripts": {
-    "build": "bun build --target=node ./index.ts --outfile=dist/index.js --external rxjs --external mutative && bun run build:declaration",
-    "build:declaration": "tsc --emitDeclarationOnly --project tsconfig.types.json --declarationMap",
-    "postbuild": "rimraf tsconfig.types.tsbuildinfo",
-    "type-check": "tsc",
+    "build": "bun build --target=node ./src/index.ts --outfile=dist/index.js --external rxjs --external mutative && bun run build:declaration",
+    "build:declaration": "tsc --emitDeclarationOnly --project tsconfig.json --declarationMap",
+    "postbuild": "rimraf tsconfig.tsbuildinfo",
+    "type-check": "tsc --noEmit",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
     "dev": "nodemon --ignore dist -e ts,tsx --exec 'bun run build'"
   },
   "dependencies": {
@@ -27,7 +29,9 @@
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
+    "@arcote.tech/arc-old": "workspace:*",
     "@types/bun": "latest",
+    "fast-check": "^3.15.0",
     "prettier": "^3.0.3",
     "rimraf": "^5.0.5",
     "typescript": "^5.2.2",

package/dist/command/command-definition.d.ts

@@ -1,5 +0,0 @@
-export type CommandDefinition = {
-    readonly commandName: string;
-    readonly parameters: any;
-};
-//# sourceMappingURL=command-definition.d.ts.map

package/dist/command/command.d.ts

@@ -1,45 +0,0 @@
-import type { ArcCommandContext } from "../context";
-import { ArcContextElement, type ArcContextElementAny } from "../context/element";
-import { ArcObject, type ArcObjectAny, type ArcRawShape } from "../elements";
-import type { $type } from "../utils";
-export type ArcCommmandHandler<ContextElements extends ArcContextElementAny[], Params extends ArcObjectAny | null, Results extends ArcObjectAny[]> = (ctx: ArcCommandContext<ContextElements>, params: Params extends ArcObjectAny ? $type<Params> : null) => Promise<$type<Results[number]>> | $type<Results[number]>;
-export declare class ArcCommand<Name extends string, Params extends ArcObjectAny | null, Results extends ArcObjectAny[], const Elements extends ArcContextElementAny[]> extends ArcContextElement<{
-    type: "execute";
-    params: Params;
-    result: Results[number];
-}, Name> {
-    readonly name: Name;
-    _description?: string;
-    _params?: Params;
-    _results?: Results;
-    _elements?: Elements;
-    _handler?: ArcCommmandHandler<Elements, Params, Results> | false;
-    _isPublic: boolean;
-    constructor(name: Name);
-    use<const E extends ArcContextElementAny[]>(elements: E): ArcCommand<Name, Params, Results, E>;
-    description(description: string): ArcCommand<Name, Params, Results, Elements>;
-    public(): ArcCommand<Name, Params, Results, Elements>;
-    get isPublic(): boolean;
-    matchesCommandPath(pathname: string): {
-        matches: boolean;
-        isPublic: boolean;
-    };
-    withParams<NewParams extends ArcRawShape>(schema: NewParams | ArcObject<NewParams>): ArcCommand<Name, ArcObject<NewParams>, Results, Elements>;
-    withResult<NewResults extends ArcRawShape[]>(...schemas: NewResults): ArcCommand<Name, Params, { [K in keyof NewResults]: ArcObject<NewResults[K]>; }, Elements>;
-    handle(handler: ArcCommmandHandler<Elements, Params, Results> | false): ArcCommand<Name, Params, Results, Elements>;
-    commandClient: (ctx: any) => (Params extends ArcObjectAny ? (params: $type<Params>) => Promise<$type<Results[number]>> : () => Promise<$type<Results[number]>>) & {
-        params: Params;
-    };
-    getUsedElements(): Elements;
-    protected clone(): ArcCommand<Name, Params, Results, Elements>;
-    toJsonSchema(): {
-        type: string;
-        name: Name;
-        description: string | undefined;
-        parameters: any;
-        strict: boolean;
-    };
-}
-export declare function command<Name extends string>(name: Name): ArcCommand<Name, null, any[], any[]>;
-export type ArcCommandAny = ArcCommand<any, any, any, any>;
-//# sourceMappingURL=command.d.ts.map

package/dist/command/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./command";
-//# sourceMappingURL=index.d.ts.map

package/dist/context/commands.d.ts

@@ -1,12 +0,0 @@
-import type { ArcContextAny } from "./context";
-export type CommandContext<C extends ArcContextAny> = ReturnType<C["commandContext"]>;
-type Command<C extends ArcContextAny> = (context: CommandContext<C>, ...args: any[]) => any;
-export type Commands<C extends ArcContextAny> = {
-    [key: string]: Command<C>;
-};
-export type CommandProxy<F> = F extends (ctx: any, ...args: infer args) => infer ret ? (...args: args) => ret : never;
-export type CommandsClient<Cmds extends Commands<any>> = {
-    [Key in keyof Cmds]: CommandProxy<Cmds[Key]>;
-};
-export {};
-//# sourceMappingURL=commands.d.ts.map

package/dist/context/element.d.ts

@@ -1,80 +0,0 @@
-import type { DataStorage } from "../data-storage";
-import type { WhereCondition } from "../data-storage/types";
-import type { QueryBuilderContext } from "./query-builder-context";
-export type EventListener<Event> = (event: Event, dataStorage: DataStorage, publishEvent: PublishEventFunction) => Promise<void>;
-export type PublishEventFunction = (event: any) => Promise<void>;
-export type ListenerConfig = {
-    handler: EventListener<any>;
-    isAsync: boolean;
-};
-export interface AuthContext {
-    ipAddress?: string;
-}
-export type AuthorizationRestrictions = {
-    default?: WhereCondition;
-    read?: boolean | WhereCondition;
-    write?: boolean | WhereCondition;
-    modify?: boolean | WhereCondition;
-    delete?: boolean | WhereCondition;
-};
-export type EventAuthorizationRestrictions = {
-    read?: boolean | WhereCondition;
-    write?: boolean | WhereCondition;
-};
-import type { ArcObject } from "../elements/object";
-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: ArcObject<any>;
-    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>;
-};
-export declare abstract class ArcContextElement<const Event, const Name extends string | undefined = undefined> {
-    readonly $event: Event;
-    readonly name?: Name;
-    queryBuilder?: (queryContext: QueryBuilderContext, authContext: AuthContext) => any;
-    commandContext?: (dataStorage: DataStorage, publishEvent: PublishEventFunction, authContext: AuthContext) => any;
-    commandClient?: (commandContext: any, authContext: AuthContext) => (...args: any[]) => any;
-    observer?: (authContext: AuthContext) => Record<string, ListenerConfig>;
-}
-export declare abstract class ArcContextElementWithStore<const Event, const Name extends string | undefined = undefined> extends ArcContextElement<Event, Name> {
-    abstract databaseStoreSchema(): DatabaseStoreSchema;
-}
-export type ArcContextElementAny = ArcContextElement<any, any>;
-//# sourceMappingURL=element.d.ts.map

package/dist/context/event.d.ts

@@ -1,45 +0,0 @@
-import type { DataStorage } from "../data-storage";
-import { ArcObject, type ArcObjectAny, type ArcRawShape } from "../elements/object";
-import type { $type } from "../utils";
-import { ArcContextElementWithStore, type AuthContext, type AuthorizationRestrictions, type EventAuthorizationRestrictions, type StoreSchema, type DatabaseStoreSchema } from "./element";
-export type EventMetadata = {
-    createdAt: Date;
-};
-export declare class ArcEvent<const Name extends string, const PayloadShape extends ArcObjectAny | undefined> extends ArcContextElementWithStore<ArcEventInstance<ArcEvent<Name, PayloadShape>>, Name> {
-    readonly name: Name;
-    readonly payload: PayloadShape;
-    private _restrictions?;
-    storeSchema: () => StoreSchema;
-    databaseStoreSchema: () => DatabaseStoreSchema;
-    constructor(name: Name, payload: PayloadShape);
-    /**
-     * Default restrictions for events - deny all operations except for system users
-     * Override using the auth() method to customize authorization
-     */
-    restrictions(authContext: AuthContext): AuthorizationRestrictions;
-    /**
-     * Define custom authorization restrictions for this event (read and write only)
-     * @param restrictionsFn - Function that takes auth context and returns read/write restrictions
-     */
-    auth(restrictionsFn: (authContext: AuthContext) => EventAuthorizationRestrictions): ArcEvent<Name, PayloadShape>;
-    commandContext: (dataStorage: DataStorage, publishEvent: (event: ArcEventInstance<ArcEvent<Name, PayloadShape>>) => Promise<void>) => {
-        emit: (payload: PayloadShape extends ArcObjectAny ? $type<PayloadShape> : undefined) => Promise<void>;
-    };
-}
-export type ArcEventInstance<Event extends ArcEventAny> = {
-    type: Event["name"];
-    payload: Event["payload"] extends ArcObjectAny ? $type<Event["payload"]> : undefined;
-} & EventMetadata;
-export type ArcEventAny = ArcEvent<any, any>;
-export type ArcEventPayload<Event extends ArcEventAny> = Event extends ArcEvent<any, infer PayloadShape extends ArcObjectAny> ? $type<PayloadShape> : undefined;
-export declare function event<const Name extends string, PayloadShape extends ArcObjectAny | ArcRawShape | undefined>(name: Name, payload?: PayloadShape): ArcEvent<Name, PayloadShape extends ArcRawShape ? ArcObject<PayloadShape, [{
-    name: "type";
-    validator: (value: any) => false | {
-        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-        expected: "object";
-    };
-}, {
-    name: "schema";
-    validator: (value: any) => false | { [key in keyof PayloadShape]: ReturnType<PayloadShape[key]["validate"]>; };
-}]> : PayloadShape extends ArcObjectAny ? PayloadShape : undefined>;
-//# sourceMappingURL=event.d.ts.map

package/dist/context/query-builder-context.d.ts

@@ -1,15 +0,0 @@
-import type { DataStorage } from "../data-storage/data-storage.abstract";
-import type { ArcQueryAny } from "./query";
-import { QueryCache } from "./query-cache";
-export declare class QueryBuilderContext {
-    private readonly queryCache;
-    private readonly dataStorage;
-    private usedQueries;
-    constructor(queryCache: QueryCache, dataStorage: DataStorage);
-    cacheQuery<T extends ArcQueryAny, Arguments extends any[]>(QueryConstructor: (new (...args: Arguments) => T) & {
-        key: string;
-    }, args: Arguments): T;
-    runQuery<T extends ArcQueryAny>(query: T): T["lastResult"];
-    getUsedQueries(): ArcQueryAny[];
-}
-//# sourceMappingURL=query-builder-context.d.ts.map

package/dist/context/query-builders.d.ts

@@ -1,17 +0,0 @@
-import type { ArcContextAny } from "./context";
-import type { ArcQueryAny } from "./query";
-import type { QueryBuilderContext } from "./query-builder-context";
-export type RunQuery<T extends ArcQueryAny> = (query: T) => T["lastResult"];
-export interface IArcQueryBuilder {
-    toQuery(context?: QueryBuilderContext): ArcQueryAny;
-}
-export declare abstract class ArcQueryBuilder implements IArcQueryBuilder {
-    protected queryContext: QueryBuilderContext;
-    constructor(queryContext: QueryBuilderContext);
-    abstract toQuery(): ArcQueryAny;
-    run(): ReturnType<this["toQuery"]>["lastResult"];
-}
-export type UnaryFunction<T, R> = (input: T) => R;
-export type QueryFactoryFunction<C extends ArcContextAny> = UnaryFunction<ReturnType<C["queryBuilder"]>, IArcQueryBuilder>;
-export type QueryBuilderFunctionResult<QueryBuilderFn extends QueryFactoryFunction<any>> = QueryBuilderFn extends QueryFactoryFunction<infer C> ? Promise<ReturnType<ReturnType<QueryBuilderFn>["toQuery"]>["lastResult"]> : never;
-//# sourceMappingURL=query-builders.d.ts.map

package/dist/context/query-cache.d.ts

@@ -1,9 +0,0 @@
-import type { ArcQueryAny } from "./query";
-export declare class QueryCache {
-    private cache;
-    private getIndexHash;
-    set(index: any[], query: ArcQueryAny): void;
-    get(index: any[]): ArcQueryAny | undefined;
-    debug(): Map<any, any>;
-}
-//# sourceMappingURL=query-cache.d.ts.map

package/dist/context/query.d.ts

@@ -1,12 +0,0 @@
-import type { DataStorage } from "../data-storage";
-export type ArcQueryListener<Result> = (result: Result) => void;
-export declare abstract class ArcQuery<Result> {
-    lastResult: Result;
-    abstract run(dataStorage: DataStorage): Promise<Result>;
-    private listeners;
-    subscribe(listener: ArcQueryListener<Result>): void;
-    unsubscribe(listener: ArcQueryListener<Result>): void;
-    nextResult(result: Result): void;
-}
-export type ArcQueryAny = ArcQuery<any>;
-//# sourceMappingURL=query.d.ts.map

package/dist/context/reactive-query.d.ts

@@ -1,23 +0,0 @@
-import { ArcQuery } from "./query";
-import type { QueryBuilderContext } from "./query-builder-context";
-import { type IArcQueryBuilder, type UnaryFunction } from "./query-builders";
-declare class ReactiveQuery<T, R> extends ArcQuery<Awaited<R>> {
-    private readonly queryContext;
-    private readonly queryBuilder;
-    private readonly fn;
-    queries: ArcQuery<any>[];
-    constructor(queryContext: QueryBuilderContext, queryBuilder: T, fn: UnaryFunction<T, R>);
-    run(): Promise<Awaited<R>>;
-    private onChangeHandler;
-    onChange(): Promise<void>;
-    runQuery(): Promise<R>;
-}
-declare class ReactiveQueryBuilder<T, R> implements IArcQueryBuilder {
-    private readonly queryBuilder;
-    private readonly fn;
-    constructor(queryBuilder: T, fn: UnaryFunction<T, R>);
-    toQuery(context: QueryBuilderContext): ReactiveQuery<T, R>;
-}
-export declare function reactive<T, R>(fn: UnaryFunction<T, R>): (context: T) => ReactiveQueryBuilder<T, R>;
-export {};
-//# sourceMappingURL=reactive-query.d.ts.map

package/dist/context/serializable-query.d.ts

@@ -1,11 +0,0 @@
-import { ArcQuery } from "./query";
-export declare abstract class ArcSerializableQuery<Result, Params> extends ArcQuery<Result> {
-    protected readonly params: Params;
-    static key: string;
-    constructor(params: Params);
-    serialize(): {
-        key: any;
-        params: Params;
-    };
-}
-//# sourceMappingURL=serializable-query.d.ts.map

package/dist/context/translator.d.ts

@@ -1,4 +0,0 @@
-import type { ArcEventAny, ArcEventInstance, ArcEventPayload } from "./event";
-export type Translation<From extends ArcEventAny, To extends ArcEventAny> = (event: ArcEventInstance<From>) => ArcEventPayload<To>;
-export declare function translate<From extends ArcEventAny, To extends ArcEventAny>(from: From, to: To, translation: Translation<From, To>): import("..").ArcListener<`${From["name"]}To${To["name"]}Translator`, [To], [From]>;
-//# sourceMappingURL=translator.d.ts.map

package/dist/database/database-mappers.d.ts

@@ -1,39 +0,0 @@
-import type { DatabaseType, DatabaseTypeMapper, DatabaseFeatures, DatabaseStoreData, DatabaseColumnDefinition } from "./database-store";
-/**
- * SQLite Type Mapper
- */
-export declare class SQLiteTypeMapper implements DatabaseTypeMapper {
-    databaseType: DatabaseType;
-    features: DatabaseFeatures;
-    mapType(arcTypeName: string, storeData?: DatabaseStoreData): string;
-    mapConstraints(storeData: DatabaseStoreData): string[];
-    generateColumnDefinition(column: DatabaseColumnDefinition): string;
-    generateCreateTableSQL(tableName: string, columns: DatabaseColumnDefinition[]): string;
-}
-/**
- * PostgreSQL Type Mapper
- */
-export declare class PostgreSQLTypeMapper implements DatabaseTypeMapper {
-    databaseType: DatabaseType;
-    features: DatabaseFeatures;
-    mapType(arcTypeName: string, storeData?: DatabaseStoreData): string;
-    mapConstraints(storeData: DatabaseStoreData): string[];
-    generateColumnDefinition(column: DatabaseColumnDefinition): string;
-    generateCreateTableSQL(tableName: string, columns: DatabaseColumnDefinition[]): string;
-}
-/**
- * MySQL Type Mapper
- */
-export declare class MySQLTypeMapper implements DatabaseTypeMapper {
-    databaseType: DatabaseType;
-    features: DatabaseFeatures;
-    mapType(arcTypeName: string, storeData?: DatabaseStoreData): string;
-    mapConstraints(storeData: DatabaseStoreData): string[];
-    generateColumnDefinition(column: DatabaseColumnDefinition): string;
-    generateCreateTableSQL(tableName: string, columns: DatabaseColumnDefinition[]): string;
-}
-/**
- * Database Type Mapper Factory
- */
-export declare function createDatabaseTypeMapper(databaseType: DatabaseType): DatabaseTypeMapper;
-//# sourceMappingURL=database-mappers.d.ts.map

package/dist/database/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./database-store";
-export * from "./schema-extraction";
-//# sourceMappingURL=index.d.ts.map

package/dist/db/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./interface";
-export * from "./postgresAdapter";
-export * from "./sqliteAdapter";
-//# sourceMappingURL=index.d.ts.map

package/dist/listener/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./listener";
-//# sourceMappingURL=index.d.ts.map

package/dist/listener/listener.d.ts

@@ -1,23 +0,0 @@
-import { type ArcCommandContext, type AuthContext } from "../context";
-import { ArcContextElement, type ArcContextElementAny, type ListenerConfig } from "../context/element";
-type GetEvents<Elements extends ArcContextElementAny[]> = Elements[number]["$event"];
-export type ArcListenerHandler<ContextElements extends ArcContextElementAny[], EventElements extends ArcContextElementAny[]> = (ctx: ArcCommandContext<ContextElements>, event: GetEvents<EventElements>) => Promise<void> | void;
-export declare class ArcListener<Name extends string, const Elements extends ArcContextElementAny[], EventElements extends ArcContextElementAny[] = ArcContextElementAny[]> extends ArcContextElement<null, Name> {
-    readonly name: Name;
-    private _description?;
-    private _elements?;
-    private _eventElements?;
-    private _handler?;
-    private _isAsync;
-    constructor(name: Name);
-    use<const E extends ArcContextElementAny[]>(elements: E): ArcListener<Name, E, EventElements>;
-    description(description: string): ArcListener<Name, Elements, EventElements>;
-    listenTo<const E extends ArcContextElementAny[]>(events: E): ArcListener<Name, Elements, E>;
-    async(): ArcListener<Name, Elements, EventElements>;
-    handle(handler: ArcListenerHandler<Elements, EventElements>): ArcListener<Name, Elements, EventElements>;
-    observer: (authContext: AuthContext) => Record<string, ListenerConfig>;
-    private clone;
-}
-export declare function listener<Name extends string>(name: Name): ArcListener<Name, any[], any[]>;
-export {};
-//# sourceMappingURL=listener.d.ts.map

package/dist/model/EventPublisher.d.ts

@@ -1,12 +0,0 @@
-import type { ArcContextAny, AuthContext } from "../context";
-import type { DataStorage } from "../data-storage";
-export declare class EventPublisher<C extends ArcContextAny> {
-    private readonly context;
-    private readonly dataStorage;
-    private readonly authContext;
-    private asyncEvents;
-    constructor(context: C, dataStorage: DataStorage, authContext: AuthContext);
-    publishEvent(event: any, commandDataStorage: DataStorage): Promise<void>;
-    runAsyncListeners(): Promise<void>;
-}
-//# sourceMappingURL=EventPublisher.d.ts.map

package/dist/model/event-publisher.d.ts

@@ -1,12 +0,0 @@
-import type { ArcContextAny, AuthContext } from "../context";
-import type { DataStorage } from "../data-storage";
-export declare class EventPublisher<C extends ArcContextAny> {
-    private readonly context;
-    private readonly dataStorage;
-    private readonly authContext;
-    private asyncEvents;
-    constructor(context: C, dataStorage: DataStorage, authContext: AuthContext);
-    publishEvent(event: any, commandDataStorage: DataStorage): Promise<void>;
-    runAsyncListeners(): Promise<void>;
-}
-//# sourceMappingURL=event-publisher.d.ts.map