@arcote.tech/arc 0.1.12 → 0.3.0

package/dist/elements/boolean.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
+import type { DatabaseAgnosticColumnInfo } from "../data-storage/database-store";
 import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
 export declare class ArcBoolean<V extends Validators> extends ArcPrimitive<V, boolean> {

package/dist/elements/branded.d.ts

@@ -1,19 +1,19 @@
-import { type util } from "../utils";
+import type { FirstArgument } from "../utils/types/first-argument";
 import { type ArcAbstractAny } from "./abstract";
 import type { ArcElement } from "./element";
 import { ArcOptional } from "./optional";
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
+import type { DatabaseAgnosticColumnInfo } from "../data-storage/database-store";
 export declare class ArcBranded<E extends ArcAbstractAny, Brand extends string | symbol> implements ArcElement {
     private parent;
     private brand;
     constructor(parent: E, brand: Brand);
-    serialize(value: util.FirstArgument<E["serialize"]> & {
+    serialize(value: FirstArgument<E["serialize"]> & {
         __brand: Brand;
     }): ReturnType<E["serialize"]>;
-    deserialize(value: util.FirstArgument<E["deserialize"]>): ReturnType<E["deserialize"]> & {
+    deserialize(value: FirstArgument<E["deserialize"]>): ReturnType<E["deserialize"]> & {
         __brand: Brand;
     };
-    parse(value: util.FirstArgument<E["parse"]>): ReturnType<E["parse"]> & {
+    parse(value: FirstArgument<E["parse"]>): ReturnType<E["parse"]> & {
         __brand: Brand;
     };
     optional(): ArcOptional<this>;

package/dist/elements/date.d.ts

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

package/dist/elements/default.d.ts

@@ -1,14 +1,14 @@
-import { type util } from "../utils";
+import type { FirstArgument } from "../utils/types/first-argument";
 import type { ArcElement } from "./element";
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
+import type { DatabaseAgnosticColumnInfo } from "../data-storage/database-store";
 export declare class ArcDefault<E extends ArcElement> implements ArcElement {
     private parent;
     private defaultValueOrCallback;
     constructor(parent: E, defaultValueOrCallback: (() => ReturnType<E["deserialize"]>) | ReturnType<E["deserialize"]>);
     validate(value: unknown): unknown;
-    parse(value: util.FirstArgument<E["parse"]> | undefined): ReturnType<E["parse"]>;
-    serialize(value: util.FirstArgument<E["serialize"]> | undefined): ReturnType<E["serialize"]>;
-    deserialize(value: util.FirstArgument<E["deserialize"]> | undefined): ReturnType<E["deserialize"]>;
+    parse(value: FirstArgument<E["parse"]> | undefined): ReturnType<E["parse"]>;
+    serialize(value: FirstArgument<E["serialize"]> | undefined): ReturnType<E["serialize"]>;
+    deserialize(value: FirstArgument<E["deserialize"]> | undefined): ReturnType<E["deserialize"]>;
     toJsonSchema(): any;
     getColumnData(): DatabaseAgnosticColumnInfo;
 }

package/dist/elements/file.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 fileValidator: {
     readonly name: "file";
     readonly validator: (value: any) => {

package/dist/elements/id.d.ts

@@ -1,15 +1,15 @@
-import type { util } from "../utils";
+import type { GetType } from "../utils/types/get-type";
 import { ArcBranded } from "./branded";
 import { ArcString } from "./string";
 export declare class ArcCustomId<Brand extends string | symbol, CreateFn extends (...args: any[]) => string> extends ArcBranded<ArcString, Brand> {
     private createFn;
     constructor(name: Brand, createFn: CreateFn);
-    get(...args: Parameters<CreateFn>): util.GetType<this>;
+    get(...args: Parameters<CreateFn>): GetType<this>;
 }
 export declare class ArcId<Brand extends string | symbol> extends ArcBranded<ArcString, Brand> {
     private generateFn?;
     constructor(name: Brand, generateFn?: (() => string) | undefined);
-    generate(): ReturnType<this["deserialize"]>;
+    generate(): GetType<this>;
 }
 export type ArcIdAny = ArcId<any> | ArcCustomId<any, any>;
 export declare function id<Brand extends string | symbol>(name: Brand, generateFn?: () => string): ArcId<Brand>;

package/dist/elements/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./abstract";
 export * from "./any";
 export * from "./array";
 export * from "./blob";

package/dist/elements/number.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 numberValidator: {
     name: "type";
     validator: (value: any) => false | {

package/dist/elements/object.d.ts

@@ -1,5 +1,6 @@
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
-import { type objectUtil, type util } from "../utils";
+import type { DatabaseAgnosticColumnInfo } from "../data-storage/database-store";
+import type { FirstArgument } from "../utils/types/first-argument";
+import type { AddQuestionMarks } from "../utils";
 import { ArcAbstract, type Validators } from "./abstract";
 import type { ArcElement } from "./element";
 import { ArcOptional } from "./optional";
@@ -25,38 +26,38 @@ export declare class ArcObject<E extends ArcRawShape, V extends Validators = [
     private rawShape;
     constructor(rawShape: E);
     parse(value: {
-        [key in keyof E]: util.FirstArgument<E[key]["parse"]>;
+        [key in keyof E]: FirstArgument<E[key]["parse"]>;
     }): {
         [key in keyof E]: ReturnType<E[key]["parse"]>;
     };
     serialize(value: {
-        [key in keyof E]: util.FirstArgument<E[key]["serialize"]>;
+        [key in keyof E]: FirstArgument<E[key]["serialize"]>;
     }): {
         [key in keyof E]: ReturnType<E[key]["serialize"]>;
     };
-    deserialize(value: objectUtil.addQuestionMarks<{
-        [key in keyof E]: util.FirstArgument<E[key]["deserialize"]>;
+    deserialize(value: AddQuestionMarks<{
+        [key in keyof E]: FirstArgument<E[key]["deserialize"]>;
     }>): {
         [key in keyof E]: ReturnType<E[key]["deserialize"]>;
     };
     deserializePath(path: string[], value: any): any;
     parsePartial(value: Partial<{
-        [key in keyof E]: util.FirstArgument<E[key]["parse"]>;
+        [key in keyof E]: FirstArgument<E[key]["parse"]>;
     }>): {
         [key in keyof E]: ReturnType<E[key]["parse"]>;
     };
     deserializePartial(value: Partial<{
-        [key in keyof E]: util.FirstArgument<E[key]["deserialize"]>;
+        [key in keyof E]: FirstArgument<E[key]["deserialize"]>;
     }>): {
         [key in keyof E]: ReturnType<E[key]["deserialize"]>;
     };
     serializePartial(value: Partial<{
-        [key in keyof E]: util.FirstArgument<E[key]["serialize"]>;
+        [key in keyof E]: FirstArgument<E[key]["serialize"]>;
     }>): {
         [key in keyof E]: ReturnType<E[key]["serialize"]>;
     };
     validatePartial(value: Partial<{
-        [key in keyof E]: util.FirstArgument<E[key]["validate"]>;
+        [key in keyof E]: FirstArgument<E[key]["validate"]>;
     }>): {
         schema: {
             [key in keyof E]: ReturnType<E[key]["validate"]>;

package/dist/elements/optional.d.ts

@@ -1,13 +1,13 @@
-import { type util } from "../utils";
+import type { FirstArgument } from "../utils/types/first-argument";
 import { type ArcAbstractAny } from "./abstract";
 import type { ArcElement } from "./element";
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
+import type { DatabaseAgnosticColumnInfo } from "../data-storage/database-store";
 export declare class ArcOptional<E extends ArcElement> implements ArcElement {
     private parent;
     constructor(parent: E);
-    parse(value: util.FirstArgument<E["parse"]> | null | undefined): ReturnType<E["parse"]> | null;
-    serialize(value: util.FirstArgument<E["serialize"]> | null | undefined): ReturnType<E["serialize"]> | null;
-    deserialize(value: util.FirstArgument<E["deserialize"]> | null | undefined): ReturnType<E["deserialize"]> | null;
+    parse(value: FirstArgument<E["parse"]> | null | undefined): ReturnType<E["parse"]> | null;
+    serialize(value: FirstArgument<E["serialize"]> | null | undefined): ReturnType<E["serialize"]> | null;
+    deserialize(value: FirstArgument<E["deserialize"]> | null | undefined): ReturnType<E["deserialize"]> | null;
     validate(value: unknown): unknown;
     toJsonSchema(): {
         anyOf: any[];

package/dist/elements/or.d.ts

@@ -1,6 +1,6 @@
-import { type util } from "../utils";
+import type { FirstArgument } from "../utils/types/first-argument";
 import type { ArcElement } from "./element";
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
+import type { DatabaseAgnosticColumnInfo } from "../data-storage/database-store";
 /**
  * ArcOr allows you to create a union schema from existing Arc elements.
  * The generic parameter keeps the type-information of every provided
@@ -13,15 +13,15 @@ export declare class ArcOr<T extends ArcElement[]> implements ArcElement {
     /**
      * Serialises a union value using the first matching element.
      */
-    serialize(value: util.FirstArgument<T[number]["serialize"]>): ReturnType<T[number]["serialize"]>;
+    serialize(value: FirstArgument<T[number]["serialize"]>): ReturnType<T[number]["serialize"]>;
     /**
      * Deserialises a raw value using the first element that validates it.
      */
-    deserialize(value: util.FirstArgument<T[number]["deserialize"]>): ReturnType<T[number]["deserialize"]>;
+    deserialize(value: FirstArgument<T[number]["deserialize"]>): ReturnType<T[number]["deserialize"]>;
     /**
      * Parses an input value using the first element that validates it.
      */
-    parse(value: util.FirstArgument<T[number]["parse"]>): ReturnType<T[number]["parse"]>;
+    parse(value: FirstArgument<T[number]["parse"]>): ReturnType<T[number]["parse"]>;
     /**
      * Runs validation on a value against **all** underlying elements.
      * Succeeds (returns `false`) when at least one element validates the value.

package/dist/elements/record.d.ts

@@ -1,10 +1,10 @@
-import { type util } from "../utils";
+import type { FirstArgument } from "../utils/types/first-argument";
 import { ArcAbstract, type Validators } from "./abstract";
 import type { ArcElement } from "./element";
 import type { ArcId } from "./id";
 import type { ArcNumber } from "./number";
 import type { ArcString } from "./string";
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
+import type { DatabaseAgnosticColumnInfo } from "../data-storage/database-store";
 type ArcKey = ArcString<any> | ArcNumber | ArcId<any>;
 export declare class ArcRecord<Key extends ArcKey, E extends ArcElement, V extends Validators = [
     {
@@ -17,7 +17,7 @@ export declare class ArcRecord<Key extends ArcKey, E extends ArcElement, V exten
     private key;
     private element;
     constructor(key: Key, element: E);
-    parse(value: Record<util.FirstArgument<Key["parse"]>, util.FirstArgument<E["parse"]>>): Record<ReturnType<Key["parse"]>, ReturnType<E["parse"]>>;
+    parse(value: Record<FirstArgument<Key["parse"]>, FirstArgument<E["parse"]>>): Record<ReturnType<Key["parse"]>, ReturnType<E["parse"]>>;
     serialize(value: Record<ReturnType<Key["serialize"]>, ReturnType<E["serialize"]>>): Record<ReturnType<Key["serialize"]>, ReturnType<E["serialize"]>>;
     deserialize(value: Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>): Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>;
     toJsonSchema(): any;

package/dist/elements/string-enum.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 ArcStringEnum<const T extends string[], V extends Validators = [
     {
         name: "schema";

package/dist/elements/string.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
+import type { DatabaseAgnosticColumnInfo } from "../data-storage/database-store";
 import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
 declare const stringValidator: {

package/dist/index.d.ts

@@ -1,13 +1,14 @@
-export * from "./command";
+/**
+ * @arcote.tech/arc
+ *
+ * Core package with improved event emission and type safety
+ */
+export * from "./adapters";
 export * from "./context";
+export * from "./context-element";
 export * from "./data-storage";
-export * from "./db";
 export * from "./elements";
-export * from "./listener";
 export * from "./model";
-export * from "./route";
-export * from "./rtc";
-export * from "./state";
+export * from "./token";
 export * from "./utils";
-export * from "./view";
 //# sourceMappingURL=index.d.ts.map