@arcote.tech/arc 0.1.0 → 0.1.3

package/dist/collection/collection.d.ts

@@ -1,4 +1,4 @@
-import { ArcContextElementWithStore, type StoreSchema } from "../context/element";
+import { ArcContextElementWithStore, type AuthContext, type AuthorizationRestrictions, type StoreSchema } from "../context/element";
 import { type ArcIdAny } from "../elements/id";
 import { type ArcObjectAny } from "../elements/object";
 import { type $type, type DeepPartial, type objectUtil, type util } from "../utils";
@@ -32,8 +32,19 @@ export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Sch
     readonly id: Id;
     readonly schema: Schema;
     readonly options: ArcCollectionOptions<Id, Schema>;
+    private _restrictions?;
     constructor(name: Name, id: Id, schema: Schema, options: ArcCollectionOptions<Id, Schema>);
     storeSchema(): StoreSchema;
+    /**
+     * Default restrictions for collections - deny all by default
+     * Use the auth() method to define custom authorization logic
+     */
+    restrictions(authContext: AuthContext): AuthorizationRestrictions;
+    /**
+     * Define custom authorization restrictions for this collection
+     * @param restrictionsFn - Function that takes auth context and returns restrictions
+     */
+    auth(restrictionsFn: (authContext: AuthContext) => AuthorizationRestrictions): ArcCollection<Name, Id, Schema>;
     serialize(data: objectUtil.simplify<{
         _id: util.FirstArgument<Id["serialize"]>;
     } & objectUtil.addQuestionMarks<util.FirstArgument<Schema["serialize"]>>>): objectUtil.simplify<{

package/dist/command/command.d.ts

@@ -2,28 +2,28 @@ 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, Result extends ArcObjectAny> = (ctx: ArcCommandContext<ContextElements>, params: Params extends ArcObjectAny ? $type<Params> : null) => Promise<$type<Result>> | $type<Result>;
-export declare class ArcCommand<Name extends string, Params extends ArcObjectAny | null, Result extends ArcObjectAny, const Elements extends ArcContextElementAny[]> extends ArcContextElement<{
+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: Result;
+    result: Results[number];
 }, Name> {
     readonly name: Name;
     private _description?;
     private _params?;
-    private _result?;
+    private _results?;
     private _elements?;
     private _handler?;
     constructor(name: Name);
-    use<const E extends ArcContextElementAny[]>(elements: E): ArcCommand<Name, Params, Result, E>;
-    description(description: string): ArcCommand<Name, Params, Result, Elements>;
-    withParams<NewParams extends ArcRawShape>(schema: NewParams | ArcObject<NewParams>): ArcCommand<Name, ArcObject<NewParams>, Result, Elements>;
-    withResult<NewResult extends ArcRawShape>(schema: NewResult): ArcCommand<Name, Params, ArcObject<NewResult>, Elements>;
-    handle(handler: ArcCommmandHandler<Elements, Params, Result> | false): ArcCommand<Name, Params, Result, Elements>;
-    commandClient: (ctx: any) => (Params extends ArcObjectAny ? (params: $type<Params>) => Promise<$type<Result>> : () => Promise<$type<Result>>) & {
+    use<const E extends ArcContextElementAny[]>(elements: E): ArcCommand<Name, Params, Results, E>;
+    description(description: string): ArcCommand<Name, Params, Results, Elements>;
+    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;
     };
     private clone;
 }
-export declare function command<Name extends string>(name: Name): ArcCommand<Name, null, any, any[]>;
+export declare function command<Name extends string>(name: Name): ArcCommand<Name, null, any[], any[]>;
 //# sourceMappingURL=command.d.ts.map

package/dist/context/context.d.ts

@@ -1,37 +1,37 @@
 import type { DataStorage } from "../data-storage";
 import type { objectUtil } from "../utils";
 import type { CommandContext } from "./commands";
-import type { ArcContextElement, ArcContextElementAny } from "./element";
+import type { ArcContextElement, ArcContextElementAny, AuthContext, EventListener, PublishEventFunction } from "./element";
 import type { QueryBuilderContext } from "./query-builder-context";
 type Filter<T extends any[], Method extends keyof T[number]> = T extends [
     infer First,
     ...infer Rest
 ] ? First[Method] extends (...args: any) => any ? [First, ...Filter<Rest, Method>] : Filter<Rest, Method> : [];
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type ArcContextElementMethodReturnType<Elements extends ArcContextElementAny[], Method extends keyof Elements[number]> = UnionToIntersection<{
+export type ArcContextElementMethodReturnType<Elements extends ArcContextElementAny[], Method extends keyof Elements[number]> = UnionToIntersection<{
     [Element in Filter<Elements, Method>[number] as number]: {
         [ElementName in Element["name"]]: Element[Method] extends (...args: any) => any ? ReturnType<Element[Method]> : undefined;
     };
 }[number]>;
 export type ArcCommandContext<E extends ArcContextElementAny[]> = ArcContextElementMethodReturnType<E, "commandContext"> & {
-    $client: any;
+    $auth: AuthContext;
 };
 export type RemoveFalseAndResolvedPromiseFromArray<T extends any[]> = T extends [infer First, ...infer Rest] ? First extends false ? RemoveFalseAndResolvedPromiseFromArray<Rest> : First extends Promise<{
     default: infer Inner;
 }> ? RemoveFalseAndResolvedPromiseFromArray<[Inner, ...Rest]> : [First, ...RemoveFalseAndResolvedPromiseFromArray<Rest>] : [];
 export declare class ArcContext<const E extends ArcContextElementAny[]> {
     readonly elements: E;
-    private eventListeners;
     constructor(elements: E);
+    getSyncListeners(eventType: string, authContext: AuthContext): EventListener<any>[];
+    getAsyncListeners(eventType: string, authContext: AuthContext): EventListener<any>[];
     pipe<const NewElements extends (ArcContextElementAny | false | Promise<{
         default: ArcContextElementAny;
     }>)[]>(newElements: NewElements): ArcContext<[
         ...E,
         ...RemoveFalseAndResolvedPromiseFromArray<NewElements>
     ]>;
-    queryBuilder(queryContext: QueryBuilderContext): ArcContextElementMethodReturnType<E, "queryBuilder">;
-    commandContext(client: string, dataStorage: DataStorage): ArcCommandContext<E>;
-    commandsClient(client: string, queryContext: QueryBuilderContext, dataStorage: DataStorage, catchErrorCallback: (error: any) => void): ArcContextElementMethodReturnType<E, "commandClient">;
+    queryBuilder(queryContext: QueryBuilderContext, authContext: AuthContext): ArcContextElementMethodReturnType<E, "queryBuilder">;
+    commandContext(dataStorage: DataStorage, publishEvent: PublishEventFunction, authContext: AuthContext): ArcCommandContext<E>;
 }
 export type ArcContextAny = ArcContext<ArcContextElementAny[]>;
 export type ElementEvents<Element extends ArcContextElementAny> = Element extends ArcContextElement<any> ? Element["$event"] : never;

package/dist/context/element.d.ts

@@ -1,6 +1,27 @@
 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) => Promise<void>;
+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 {
+    userId: string;
+    roles: 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;
+};
 export type StoreColumn = {
     name: string;
     type: string;
@@ -28,10 +49,10 @@ export type StoreSchema = {
 export declare abstract class ArcContextElement<const Event, const Name extends string | undefined = undefined> {
     readonly $event: Event;
     readonly name?: Name;
-    queryBuilder?(queryContext: QueryBuilderContext): any;
-    commandContext?: (dataStorage: DataStorage, publishEvent: (event: Event) => Promise<void>) => any;
-    commandClient?: (commandContext: any) => (...args: any[]) => any;
-    observer?: () => Record<string, EventListener<Event>>;
+    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 storeSchema(): StoreSchema;

package/dist/context/event.d.ts

@@ -1,7 +1,7 @@
 import type { DataStorage } from "../data-storage";
 import { ArcObject, type ArcObjectAny, type ArcRawShape } from "../elements/object";
 import type { $type } from "../utils";
-import { ArcContextElementWithStore, type StoreSchema } from "./element";
+import { ArcContextElementWithStore, type AuthContext, type AuthorizationRestrictions, type EventAuthorizationRestrictions, type StoreSchema } from "./element";
 export type EventMetadata = {
     occurredAt: string;
     createdBy?: {
@@ -15,8 +15,19 @@ export type EventMetadata = {
 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;
     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>;
     };

package/dist/context/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./commands";
 export * from "./context";
+export * from "./element";
 export * from "./event";
 export * from "./query";
 export * from "./query-builder-context";

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

@@ -0,0 +1,33 @@
+import type { DataStorage } from "../data-storage";
+import type { FindOptions } from "../data-storage/types";
+export type QueryFunction<T> = (dataStorage: DataStorage) => (options: FindOptions<T>) => Promise<T[]>;
+export type QueryFunctionOne<T> = (dataStorage: DataStorage) => (options: FindOptions<T>) => Promise<T | undefined>;
+export type SimpleQueryListener<Result> = (result: Result) => void;
+export declare class SimpleQueryResult<T> {
+    private data;
+    constructor(data: T);
+    get(): T;
+    exists(): boolean;
+    toArray(): (T & any[]) | never[];
+    map<U>(callbackfn: (value: any, index: number, array: any[]) => U): U[];
+}
+export declare class SimpleQuery<T> {
+    private queryFn;
+    private options;
+    private storeName;
+    private listeners;
+    private lastResult;
+    private resultIds;
+    constructor(queryFn: QueryFunction<T> | QueryFunctionOne<T>, options: FindOptions<T>, storeName: string);
+    run(dataStorage: DataStorage): Promise<SimpleQueryResult<T>>;
+    private updateResultIds;
+    getResultIds(): Set<string>;
+    getOptions(): FindOptions<T>;
+    getStoreName(): string;
+    subscribe(listener: SimpleQueryListener<SimpleQueryResult<T>>): void;
+    unsubscribe(listener: SimpleQueryListener<SimpleQueryResult<T>>): void;
+    updateResult(newResult: SimpleQueryResult<T>): void;
+    getLastResult(): SimpleQueryResult<T>;
+    getCacheKey(): string;
+}
+//# sourceMappingURL=simple-query.d.ts.map

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

@@ -0,0 +1,16 @@
+import type { ArcContextAny } from "../context";
+import type { AuthContext } from "../context/element";
+import type { DatabaseAdapter } from "../db";
+import type { RealTimeCommunicationAdapterFactory } from "../rtc/rtc";
+import type { DataStorage } from "./data-storage.abstract";
+export declare class DataStorageBuilder {
+    private dbAdapter;
+    private rtcAdapterFactory;
+    private arcContext;
+    constructor(dbAdapter: Promise<DatabaseAdapter> | DatabaseAdapter, rtcAdapterFactory: RealTimeCommunicationAdapterFactory, arcContext: ArcContextAny);
+    /**
+     * Create a DataStorage instance
+     */
+    build(authContext: AuthContext): DataStorage;
+}
+//# sourceMappingURL=data-storage-builder.d.ts.map

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

@@ -1,7 +1,9 @@
 export * from "./data-storage-forked";
 export * from "./data-storage-master";
 export * from "./data-storage.abstract";
+export * from "./deep-merge";
 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/data-storage/query-processor.d.ts

@@ -0,0 +1,22 @@
+import { SimpleQuery } from "../context/simple-query";
+import type { ListenerEvent } from "./data-storage.abstract";
+import type { FindOptions } from "./types";
+export type QueryRerunCallback = <T>(query: SimpleQuery<T>) => Promise<void>;
+export declare class QueryProcessor {
+    private activeQueries;
+    private rerunCallback?;
+    setRerunCallback(callback: QueryRerunCallback): void;
+    registerQuery<T>(query: SimpleQuery<T>): void;
+    unregisterQuery<T>(query: SimpleQuery<T>): void;
+    processStoreChange<T extends {
+        _id: string;
+    }>(storeName: string, event: ListenerEvent<T>): void;
+    private processQueryChange;
+    private rerunQuery;
+    /**
+     * Check if an item matches the query conditions
+     * This is the filtering logic moved from find.ts and find-one.ts
+     */
+    checkItemMatchesQuery<T>(item: T, options: FindOptions<T>): boolean;
+}
+//# sourceMappingURL=query-processor.d.ts.map

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

@@ -0,0 +1,26 @@
+import type { ArcContextAny } from "../context";
+import type { AuthContext } from "../context/element";
+import type { DataStorage, QueryListenerCallback, StoreStateChange } from "./data-storage.abstract";
+import { StoreState } from "./store-state.abstract";
+import type { FindOptions } from "./types";
+export declare class AuthorizedStoreState<Item extends {
+    _id: string;
+}> extends StoreState<Item> {
+    private arcContext;
+    private authContext;
+    constructor(storeName: string, dataStorage: DataStorage, arcContext: ArcContextAny, authContext: AuthContext, deserialize?: (data: any) => Item);
+    private getElementRestrictions;
+    private checkOperationPermission;
+    private applyAuthorizationFilter;
+    find(options: FindOptions<Item>, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
+    applyChange(change: StoreStateChange<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }>;
+    applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
+    applySerializedChanges(changes: StoreStateChange<Item>[]): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }[]>;
+}
+//# sourceMappingURL=store-state-authorized.d.ts.map

package/dist/db/sqliteAdapter.d.ts

@@ -1,5 +1,5 @@
 import { type ArcContextAny } from "../context";
-import type { StoreTable } from "../context/element";
+import type { StoreColumn, StoreTable } from "../context/element";
 import type { FindOptions, WhereCondition } from "../data-storage/types";
 import type { DatabaseAdapter, DBAdapterFactory, ReadTransaction, ReadWriteTransaction } from "./interface";
 export interface SQLiteDatabase {
@@ -9,6 +9,8 @@ declare class SQLiteReadTransaction implements ReadTransaction {
     protected db: SQLiteDatabase;
     protected tables: Map<string, StoreTable>;
     constructor(db: SQLiteDatabase, tables: Map<string, StoreTable>);
+    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): {
         sql: string;

package/dist/elements/blob.d.ts

@@ -0,0 +1,79 @@
+import type { CheckFn, GetValidator, Validators } from "./abstract";
+import { ArcPrimitive } from "./abstract-primitive";
+declare const blobValidator: {
+    readonly name: "blob";
+    readonly validator: (value: any) => {
+        currentType: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expectedType: string;
+    } | undefined;
+};
+export declare class ArcBlob<V extends Validators = [typeof blobValidator]> extends ArcPrimitive<V, Blob> {
+    constructor();
+    /**
+     * Validate that the blob has a specific MIME type
+     */
+    type(mimeType: string): ArcBlob<[...V, {
+        name: "type";
+        validator: (value: any) => {
+            currentType: string;
+            expectedType: string;
+        } | undefined;
+    }]>;
+    /**
+     * Validate that the blob has one of the specified MIME types
+     */
+    types(mimeTypes: string[]): ArcBlob<[...V, {
+        name: "types";
+        validator: (value: any) => {
+            currentType: string;
+            expectedTypes: string[];
+        } | undefined;
+    }]>;
+    /**
+     * Validate minimum blob size in bytes
+     */
+    minSize(bytes: number): ArcBlob<[...V, {
+        name: "minSize";
+        validator: (value: any) => {
+            currentSize: number;
+            minSize: number;
+        } | undefined;
+    }]>;
+    /**
+     * Validate maximum blob size in bytes
+     */
+    maxSize(bytes: number): ArcBlob<[...V, {
+        name: "maxSize";
+        validator: (value: any) => {
+            currentSize: number;
+            maxSize: number;
+        } | undefined;
+    }]>;
+    /**
+     * Validate exact blob size in bytes
+     */
+    size(bytes: number): ArcBlob<[...V, {
+        name: "size";
+        validator: (value: any) => {
+            currentSize: number;
+            expectedSize: number;
+        } | undefined;
+    }]>;
+    validation<Name extends string, Fn extends CheckFn<any>>(name: Name, validator: Fn): ArcBlob<GetValidator<import("./abstract").ArcAbstract<[...V, {
+        name: Name;
+        validator: Fn;
+    }]>>>;
+    /**
+     * Override parse to validate blob objects
+     */
+    parse(value: any): Blob;
+}
+export declare function blob(): ArcBlob<[{
+    readonly name: "blob";
+    readonly validator: (value: any) => {
+        currentType: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expectedType: string;
+    } | undefined;
+}]>;
+export {};
+//# sourceMappingURL=blob.d.ts.map

package/dist/elements/boolean.d.ts

@@ -1,5 +1,16 @@
+import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
-export declare class ArcBoolean extends ArcPrimitive<[], boolean> {
+export declare class ArcBoolean<V extends Validators> extends ArcPrimitive<V, boolean> {
+    hasToBeTrue(): ArcBoolean<[...V, {
+        name: "hasToBeTrue";
+        validator: (value: any[]) => {
+            current: never;
+        } | undefined;
+    }]>;
+    validation<Name extends string, Fn extends CheckFn<any>>(name: Name, validator: Fn): ArcBoolean<GetValidator<import("./abstract").ArcAbstract<[...V, {
+        name: Name;
+        validator: Fn;
+    }]>>>;
 }
-export declare function boolean(): ArcBoolean;
+export declare function boolean(): ArcBoolean<Validators>;
 //# sourceMappingURL=boolean.d.ts.map

package/dist/elements/date.d.ts

@@ -1,5 +1,5 @@
-import { ArcAbstract } from "./abstract";
 import type { CheckFn, GetValidator, Validators } from "./abstract";
+import { ArcAbstract } from "./abstract";
 declare const dateValidator: {
     name: "type";
     validator: (value: any) => false | {

package/dist/elements/file.d.ts

@@ -0,0 +1,139 @@
+import type { CheckFn, GetValidator, Validators } from "./abstract";
+import { ArcPrimitive } from "./abstract-primitive";
+declare const fileValidator: {
+    readonly name: "file";
+    readonly validator: (value: any) => {
+        currentType: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expectedType: string;
+    } | undefined;
+};
+export declare class ArcFile<V extends Validators = [typeof fileValidator]> extends ArcPrimitive<V, File> {
+    constructor();
+    /**
+     * Validate that the file has a specific MIME type
+     */
+    type(mimeType: string): ArcFile<[...V, {
+        name: "type";
+        validator: (value: any) => {
+            currentType: string;
+            expectedType: string;
+        } | undefined;
+    }]>;
+    /**
+     * Validate that the file has one of the specified MIME types
+     */
+    types(mimeTypes: string[]): ArcFile<[...V, {
+        name: "types";
+        validator: (value: any) => {
+            currentType: string;
+            expectedTypes: string[];
+        } | undefined;
+    }]>;
+    /**
+     * Validate minimum file size in bytes
+     */
+    minSize(bytes: number): ArcFile<[...V, {
+        name: "minSize";
+        validator: (value: any) => {
+            currentSize: number;
+            minSize: number;
+        } | undefined;
+    }]>;
+    /**
+     * Validate maximum file size in bytes
+     */
+    maxSize(bytes: number): ArcFile<[...V, {
+        name: "maxSize";
+        validator: (value: any) => {
+            currentSize: number;
+            maxSize: number;
+        } | undefined;
+    }]>;
+    /**
+     * Validate exact file size in bytes
+     */
+    size(bytes: number): ArcFile<[...V, {
+        name: "size";
+        validator: (value: any) => {
+            currentSize: number;
+            expectedSize: number;
+        } | undefined;
+    }]>;
+    /**
+     * Validate the file name
+     */
+    name(expectedName: string): ArcFile<[...V, {
+        name: "name";
+        validator: (value: any) => {
+            currentName: string;
+            expectedName: string;
+        } | undefined;
+    }]>;
+    /**
+     * Validate the file name matches a pattern
+     */
+    namePattern(pattern: RegExp): ArcFile<[...V, {
+        name: "namePattern";
+        validator: (value: any) => {
+            currentName: string;
+            pattern: string;
+        } | undefined;
+    }]>;
+    /**
+     * Validate file extension
+     */
+    extension(ext: string): ArcFile<[...V, {
+        name: "extension";
+        validator: (value: any) => {
+            currentExtension: string | undefined;
+            expectedExtension: string;
+        } | undefined;
+    }]>;
+    /**
+     * Validate file has one of the specified extensions
+     */
+    extensions(exts: string[]): ArcFile<[...V, {
+        name: "extensions";
+        validator: (value: any) => {
+            currentExtension: string | undefined;
+            expectedExtensions: string[];
+        } | undefined;
+    }]>;
+    /**
+     * Validate the file's last modified date
+     */
+    lastModifiedAfter(date: Date): ArcFile<[...V, {
+        name: "lastModifiedAfter";
+        validator: (value: any) => {
+            currentLastModified: Date;
+            expectedAfter: Date;
+        } | undefined;
+    }]>;
+    /**
+     * Validate the file's last modified date
+     */
+    lastModifiedBefore(date: Date): ArcFile<[...V, {
+        name: "lastModifiedBefore";
+        validator: (value: any) => {
+            currentLastModified: Date;
+            expectedBefore: Date;
+        } | undefined;
+    }]>;
+    validation<Name extends string, Fn extends CheckFn<any>>(name: Name, validator: Fn): ArcFile<GetValidator<import("./abstract").ArcAbstract<[...V, {
+        name: Name;
+        validator: Fn;
+    }]>>>;
+    /**
+     * Override parse to validate file objects
+     */
+    parse(value: any): File;
+}
+export declare function file(): ArcFile<[{
+    readonly name: "file";
+    readonly validator: (value: any) => {
+        currentType: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expectedType: string;
+    } | undefined;
+}]>;
+export {};
+//# sourceMappingURL=file.d.ts.map

package/dist/elements/index.d.ts

@@ -1,8 +1,11 @@
 export * from "./array";
+export * from "./blob";
 export * from "./boolean";
 export * from "./branded";
 export * from "./class";
 export * from "./date";
+export * from "./element";
+export * from "./file";
 export * from "./id";
 export * from "./number";
 export * from "./object";

package/dist/elements/object.d.ts

@@ -53,6 +53,13 @@ export declare class ArcObject<E extends ArcRawShape, V extends Validators = [
     }>): {
         [key in keyof E]: ReturnType<E[key]["serialize"]>;
     };
+    validatePartial(value: Partial<{
+        [key in keyof E]: util.FirstArgument<E[key]["validate"]>;
+    }>): {
+        schema: {
+            [key in keyof E]: ReturnType<E[key]["validate"]>;
+        };
+    } | false;
     pick<Keys extends keyof E>(...keys: Keys[]): ArcObject<Pick<E, Keys>, V>;
     omit<Keys extends keyof E>(...keys: Keys[]): ArcObject<Omit<E, Keys>, V>;
     entries(): [string, ArcElement][];

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export * from "./context";
 export * from "./data-storage";
 export * from "./db";
 export * from "./elements";
+export * from "./listener";
 export * from "./model";
 export * from "./rtc";
 export * from "./state";