@sidekick-coder/zenith-kit 0.3.7 → 0.3.8

package/dist/client/src/shared/mixins/HooksMixin.d.ts

@@ -0,0 +1,26 @@
+import { Constructor } from '../utils/compose.ts';
+export interface Listener {
+    event: string;
+    listener: (...args: any[]) => void;
+}
+export declare function emitHook(constructor: any, event: string, ...args: any[]): Promise<void>;
+export declare function onHook(constructor: any, event: string, listener: (...args: any[]) => void): void;
+export declare function HooksStatic<TBase extends Constructor>(Base: TBase): {
+    new (...args: any[]): {};
+    listeners: Array<(...args: any[]) => void>;
+    on(event: string, listener: (...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): Promise<void>;
+} & TBase;
+export declare namespace HooksStatic {
+    var emit: typeof emitHook;
+    var on: typeof onHook;
+}
+export default function Hooks<TBase extends Constructor>(Base: TBase): {
+    new (...args: any[]): {
+        listeners: Listener[];
+        on(event: string, listener: (...args: any[]) => void): void;
+        off(event: string, listener: (...args: any[]) => void): void;
+        emit(event: string, ...args: any[]): void;
+        emitAsync(event: string, ...args: any[]): Promise<void>;
+    };
+} & TBase;

package/dist/client/src/shared/mixins/SoftDeleteMixin.d.ts

@@ -0,0 +1,6 @@
+import { Constructor } from '../utils/compose.ts';
+export default function SoftDeleteMixin<T extends Constructor>(base: T): {
+    new (...args: any[]): {
+        deleted_at: Date | string | null;
+    };
+} & T;

package/dist/client/src/shared/mixins/TimestampMixin.d.ts

@@ -0,0 +1,7 @@
+import { Constructor } from '../utils/compose.ts';
+export default function TimestampMixin<T extends Constructor>(base: T): {
+    new (...args: any[]): {
+        created_at: Date | string;
+        updated_at: Date | string;
+    };
+} & T;

package/dist/client/src/shared/schemas/dashboardMetaSchema.d.ts

@@ -0,0 +1,124 @@
+import { ValidatorResult } from '../services/ValidatorService.ts';
+import { ObjectSchema, NumberSchema, StringSchema, NullableSchema } from 'valibot';
+export type DashboardMetaSchema = ValidatorResult<ReturnType<typeof dashboardMetaSchema>>;
+export declare function dashboardMetaSchema(): ObjectSchema<{
+    readonly id: NumberSchema<undefined>;
+    readonly dashboard_id: NumberSchema<undefined>;
+    readonly name: StringSchema<undefined>;
+    readonly value: NullableSchema<StringSchema<undefined>, undefined>;
+}, undefined>;
+export declare namespace dashboardMetaSchema {
+    var create: Omit<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").NumberSchema<undefined>;
+        readonly dashboard_id: import("valibot").NumberSchema<undefined>;
+        readonly name: import("valibot").StringSchema<undefined>;
+        readonly value: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>, "entries" | "~types" | "~run" | "~standard"> & {
+        readonly entries: Pick<{
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly dashboard_id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").StringSchema<undefined>;
+            readonly value: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, "value" | "name" | "dashboard_id">;
+        readonly "~standard": import("valibot").StandardProps<{
+            value: string | null;
+            name: string;
+            dashboard_id: number;
+        }, {
+            value: string | null;
+            name: string;
+            dashboard_id: number;
+        }>;
+        readonly "~run": (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
+            value: string | null;
+            name: string;
+            dashboard_id: number;
+        }, import("valibot").StringIssue | import("valibot").NumberIssue | import("valibot").ObjectIssue>;
+        readonly "~types"?: {
+            readonly input: {
+                value: string | null;
+                name: string;
+                dashboard_id: number;
+            };
+            readonly output: {
+                value: string | null;
+                name: string;
+                dashboard_id: number;
+            };
+            readonly issue: import("valibot").StringIssue | import("valibot").NumberIssue | import("valibot").ObjectIssue;
+        } | undefined;
+    };
+    var update: Omit<Omit<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").NumberSchema<undefined>;
+        readonly dashboard_id: import("valibot").NumberSchema<undefined>;
+        readonly name: import("valibot").StringSchema<undefined>;
+        readonly value: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>, "entries" | "~types" | "~run" | "~standard"> & {
+        readonly entries: Pick<{
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly dashboard_id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").StringSchema<undefined>;
+            readonly value: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, "value" | "name" | "dashboard_id">;
+        readonly "~standard": import("valibot").StandardProps<{
+            value: string | null;
+            name: string;
+            dashboard_id: number;
+        }, {
+            value: string | null;
+            name: string;
+            dashboard_id: number;
+        }>;
+        readonly "~run": (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
+            value: string | null;
+            name: string;
+            dashboard_id: number;
+        }, import("valibot").StringIssue | import("valibot").NumberIssue | import("valibot").ObjectIssue>;
+        readonly "~types"?: {
+            readonly input: {
+                value: string | null;
+                name: string;
+                dashboard_id: number;
+            };
+            readonly output: {
+                value: string | null;
+                name: string;
+                dashboard_id: number;
+            };
+            readonly issue: import("valibot").StringIssue | import("valibot").NumberIssue | import("valibot").ObjectIssue;
+        } | undefined;
+    }, "entries" | "~types" | "~run" | "~standard"> & {
+        readonly entries: {
+            readonly value: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+            readonly name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly dashboard_id: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        };
+        readonly "~standard": import("valibot").StandardProps<{
+            value?: string | null | undefined;
+            name?: string | undefined;
+            dashboard_id?: number | undefined;
+        }, {
+            value?: string | null | undefined;
+            name?: string | undefined;
+            dashboard_id?: number | undefined;
+        }>;
+        readonly "~run": (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
+            value?: string | null | undefined;
+            name?: string | undefined;
+            dashboard_id?: number | undefined;
+        }, import("valibot").StringIssue | import("valibot").NumberIssue | import("valibot").ObjectIssue>;
+        readonly "~types"?: {
+            readonly input: {
+                value?: string | null | undefined;
+                name?: string | undefined;
+                dashboard_id?: number | undefined;
+            };
+            readonly output: {
+                value?: string | null | undefined;
+                name?: string | undefined;
+                dashboard_id?: number | undefined;
+            };
+            readonly issue: import("valibot").StringIssue | import("valibot").NumberIssue | import("valibot").ObjectIssue;
+        } | undefined;
+    };
+}

package/dist/client/src/shared/schemas/dashboardSchema.d.ts

@@ -0,0 +1,123 @@
+import { ValidatorResult } from '../services/ValidatorService.ts';
+import { ObjectSchema, NumberSchema, StringSchema, NullableSchema, OptionalSchema, RecordSchema, AnySchema } from 'valibot';
+export type DashboardSchema = ValidatorResult<ReturnType<typeof dashboardSchema>>;
+export declare function dashboardSchema(): ObjectSchema<{
+    readonly id: NumberSchema<undefined>;
+    readonly name: StringSchema<undefined>;
+    readonly description: NullableSchema<StringSchema<undefined>, undefined>;
+    readonly created_at: StringSchema<undefined>;
+    readonly updated_at: StringSchema<undefined>;
+    readonly deleted_at: NullableSchema<StringSchema<undefined>, undefined>;
+    readonly metas: OptionalSchema<RecordSchema<StringSchema<undefined>, AnySchema, undefined>, undefined>;
+}, undefined>;
+export declare namespace dashboardSchema {
+    var create: Omit<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").NumberSchema<undefined>;
+        readonly name: import("valibot").StringSchema<undefined>;
+        readonly description: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly created_at: import("valibot").StringSchema<undefined>;
+        readonly updated_at: import("valibot").StringSchema<undefined>;
+        readonly deleted_at: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly metas: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").AnySchema, undefined>, undefined>;
+    }, undefined>, "entries" | "~types" | "~run" | "~standard"> & {
+        readonly entries: Pick<{
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").StringSchema<undefined>;
+            readonly description: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly created_at: import("valibot").StringSchema<undefined>;
+            readonly updated_at: import("valibot").StringSchema<undefined>;
+            readonly deleted_at: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly metas: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").AnySchema, undefined>, undefined>;
+        }, "name" | "description">;
+        readonly "~standard": import("valibot").StandardProps<{
+            name: string;
+            description: string | null;
+        }, {
+            name: string;
+            description: string | null;
+        }>;
+        readonly "~run": (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
+            name: string;
+            description: string | null;
+        }, import("valibot").StringIssue | import("valibot").ObjectIssue>;
+        readonly "~types"?: {
+            readonly input: {
+                name: string;
+                description: string | null;
+            };
+            readonly output: {
+                name: string;
+                description: string | null;
+            };
+            readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue;
+        } | undefined;
+    };
+    var update: Omit<Omit<import("valibot").ObjectSchema<{
+        readonly id: import("valibot").NumberSchema<undefined>;
+        readonly name: import("valibot").StringSchema<undefined>;
+        readonly description: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly created_at: import("valibot").StringSchema<undefined>;
+        readonly updated_at: import("valibot").StringSchema<undefined>;
+        readonly deleted_at: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly metas: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").AnySchema, undefined>, undefined>;
+    }, undefined>, "entries" | "~types" | "~run" | "~standard"> & {
+        readonly entries: Pick<{
+            readonly id: import("valibot").NumberSchema<undefined>;
+            readonly name: import("valibot").StringSchema<undefined>;
+            readonly description: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly created_at: import("valibot").StringSchema<undefined>;
+            readonly updated_at: import("valibot").StringSchema<undefined>;
+            readonly deleted_at: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly metas: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").AnySchema, undefined>, undefined>;
+        }, "name" | "description">;
+        readonly "~standard": import("valibot").StandardProps<{
+            name: string;
+            description: string | null;
+        }, {
+            name: string;
+            description: string | null;
+        }>;
+        readonly "~run": (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
+            name: string;
+            description: string | null;
+        }, import("valibot").StringIssue | import("valibot").ObjectIssue>;
+        readonly "~types"?: {
+            readonly input: {
+                name: string;
+                description: string | null;
+            };
+            readonly output: {
+                name: string;
+                description: string | null;
+            };
+            readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue;
+        } | undefined;
+    }, "entries" | "~types" | "~run" | "~standard"> & {
+        readonly entries: {
+            readonly name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly description: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+        };
+        readonly "~standard": import("valibot").StandardProps<{
+            name?: string | undefined;
+            description?: string | null | undefined;
+        }, {
+            name?: string | undefined;
+            description?: string | null | undefined;
+        }>;
+        readonly "~run": (dataset: import("valibot").UnknownDataset, config: import("valibot").Config<import("valibot").BaseIssue<unknown>>) => import("valibot").OutputDataset<{
+            name?: string | undefined;
+            description?: string | null | undefined;
+        }, import("valibot").StringIssue | import("valibot").ObjectIssue>;
+        readonly "~types"?: {
+            readonly input: {
+                name?: string | undefined;
+                description?: string | null | undefined;
+            };
+            readonly output: {
+                name?: string | undefined;
+                description?: string | null | undefined;
+            };
+            readonly issue: import("valibot").StringIssue | import("valibot").ObjectIssue;
+        } | undefined;
+    };
+}

package/dist/client/src/shared/schemas/permissionAssignmentSchema.d.ts

@@ -0,0 +1,10 @@
+import * as v from 'valibot';
+export type PermissionAssignment = v.InferOutput<typeof permissionAssignmentSchema>;
+export declare const permissionAssignmentSchema: v.ObjectSchema<{
+    readonly id: v.NumberSchema<undefined>;
+    readonly permission_id: v.NumberSchema<undefined>;
+    readonly assignable_type: v.StringSchema<undefined>;
+    readonly assignable_id: v.StringSchema<undefined>;
+    readonly created_at: v.StringSchema<undefined>;
+    readonly updated_at: v.StringSchema<undefined>;
+}, undefined>;

package/dist/client/src/shared/schemas/permissionSchema.d.ts

@@ -0,0 +1,13 @@
+import * as v from 'valibot';
+export type Permission = v.InferOutput<typeof permissionSchema>;
+export declare const permissionSchema: v.ObjectSchema<{
+    readonly id: v.NumberSchema<undefined>;
+    readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly action: v.StringSchema<undefined>;
+    readonly subject: v.StringSchema<undefined>;
+    readonly conditions: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly created_at: v.StringSchema<undefined>;
+    readonly updated_at: v.StringSchema<undefined>;
+    readonly expires_at: v.StringSchema<undefined>;
+}, undefined>;

package/dist/client/src/shared/schemas/tokenSchema.d.ts

@@ -0,0 +1,12 @@
+import * as v from 'valibot';
+export type Token = v.InferOutput<typeof tokenSchema>;
+export declare const tokenSchema: v.ObjectSchema<{
+    readonly id: v.NumberSchema<undefined>;
+    readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly type: v.StringSchema<undefined>;
+    readonly user_id: v.NumberSchema<undefined>;
+    readonly token: v.StringSchema<undefined>;
+    readonly created_at: v.StringSchema<undefined>;
+    readonly updated_at: v.StringSchema<undefined>;
+    readonly expires_at: v.StringSchema<undefined>;
+}, undefined>;

package/dist/client/src/shared/schemas/userSchema.d.ts

@@ -0,0 +1,164 @@
+import * as v from 'valibot';
+declare function userSchema(): v.ObjectSchema<{
+    readonly id: v.NumberSchema<undefined>;
+    readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly email: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>;
+    readonly password: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 6, undefined>]>;
+    readonly username: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+    readonly verified_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly created_at: v.StringSchema<undefined>;
+    readonly updated_at: v.StringSchema<undefined>;
+    readonly deleted_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+declare namespace userSchema {
+    var create: () => Omit<v.ObjectSchema<{
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly email: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>;
+        readonly password: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 6, undefined>]>;
+        readonly username: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+        readonly verified_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly created_at: v.StringSchema<undefined>;
+        readonly updated_at: v.StringSchema<undefined>;
+        readonly deleted_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, "entries" | "~types" | "~run" | "~standard"> & {
+        readonly entries: Omit<{
+            readonly id: v.NumberSchema<undefined>;
+            readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly email: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>;
+            readonly password: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 6, undefined>]>;
+            readonly username: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+            readonly verified_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly created_at: v.StringSchema<undefined>;
+            readonly updated_at: v.StringSchema<undefined>;
+            readonly deleted_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, "created_at" | "updated_at" | "deleted_at" | "id" | "verified_at">;
+        readonly "~standard": v.StandardProps<{
+            name?: string | undefined;
+            email: string;
+            username: string;
+            password: string;
+        }, {
+            name?: string | undefined;
+            email: string;
+            username: string;
+            password: string;
+        }>;
+        readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+            name?: string | undefined;
+            email: string;
+            username: string;
+            password: string;
+        }, v.StringIssue | v.ObjectIssue | v.EmailIssue<string> | v.MinLengthIssue<string, 6> | v.RegexIssue<string>>;
+        readonly "~types"?: {
+            readonly input: {
+                name?: string | undefined;
+                email: string;
+                username: string;
+                password: string;
+            };
+            readonly output: {
+                name?: string | undefined;
+                email: string;
+                username: string;
+                password: string;
+            };
+            readonly issue: v.StringIssue | v.ObjectIssue | v.EmailIssue<string> | v.MinLengthIssue<string, 6> | v.RegexIssue<string>;
+        } | undefined;
+    };
+    var update: () => Omit<Omit<v.ObjectSchema<{
+        readonly id: v.NumberSchema<undefined>;
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly email: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>;
+        readonly password: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 6, undefined>]>;
+        readonly username: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+        readonly verified_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly created_at: v.StringSchema<undefined>;
+        readonly updated_at: v.StringSchema<undefined>;
+        readonly deleted_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, "entries" | "~types" | "~run" | "~standard"> & {
+        readonly entries: Omit<{
+            readonly id: v.NumberSchema<undefined>;
+            readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly email: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>;
+            readonly password: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 6, undefined>]>;
+            readonly username: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>;
+            readonly verified_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly created_at: v.StringSchema<undefined>;
+            readonly updated_at: v.StringSchema<undefined>;
+            readonly deleted_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, "created_at" | "updated_at" | "deleted_at" | "id" | "verified_at">;
+        readonly "~standard": v.StandardProps<{
+            name?: string | undefined;
+            email: string;
+            username: string;
+            password: string;
+        }, {
+            name?: string | undefined;
+            email: string;
+            username: string;
+            password: string;
+        }>;
+        readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+            name?: string | undefined;
+            email: string;
+            username: string;
+            password: string;
+        }, v.StringIssue | v.ObjectIssue | v.EmailIssue<string> | v.MinLengthIssue<string, 6> | v.RegexIssue<string>>;
+        readonly "~types"?: {
+            readonly input: {
+                name?: string | undefined;
+                email: string;
+                username: string;
+                password: string;
+            };
+            readonly output: {
+                name?: string | undefined;
+                email: string;
+                username: string;
+                password: string;
+            };
+            readonly issue: v.StringIssue | v.ObjectIssue | v.EmailIssue<string> | v.MinLengthIssue<string, 6> | v.RegexIssue<string>;
+        } | undefined;
+    }, "entries" | "~types" | "~run" | "~standard"> & {
+        readonly entries: {
+            readonly name: v.OptionalSchema<v.OptionalSchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly email: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>]>, undefined>;
+            readonly username: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>;
+            readonly password: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 6, undefined>]>, undefined>;
+        };
+        readonly "~standard": v.StandardProps<{
+            name?: string | undefined;
+            email?: string | undefined;
+            username?: string | undefined;
+            password?: string | undefined;
+        }, {
+            name?: string | undefined;
+            email?: string | undefined;
+            username?: string | undefined;
+            password?: string | undefined;
+        }>;
+        readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+            name?: string | undefined;
+            email?: string | undefined;
+            username?: string | undefined;
+            password?: string | undefined;
+        }, v.StringIssue | v.ObjectIssue | v.EmailIssue<string> | v.MinLengthIssue<string, 6> | v.RegexIssue<string>>;
+        readonly "~types"?: {
+            readonly input: {
+                name?: string | undefined;
+                email?: string | undefined;
+                username?: string | undefined;
+                password?: string | undefined;
+            };
+            readonly output: {
+                name?: string | undefined;
+                email?: string | undefined;
+                username?: string | undefined;
+                password?: string | undefined;
+            };
+            readonly issue: v.StringIssue | v.ObjectIssue | v.EmailIssue<string> | v.MinLengthIssue<string, 6> | v.RegexIssue<string>;
+        } | undefined;
+    };
+}
+export default userSchema;

package/dist/client/src/shared/services/ConfigService.d.ts

@@ -0,0 +1,23 @@
+interface Entry {
+    key: string;
+    value: any;
+    source: string;
+}
+export default class ConfigService {
+    static __container_entry_key: string;
+    entries: Map<string, Entry>;
+    constructor();
+    list(): Entry[];
+    parseValue(value: any): any;
+    loadFromRecord(record: Record<string, any>, source?: string): void;
+    loadFromEntries(entries: [string, any][], source?: string): void;
+    toRecord(): Record<string, any>;
+    has(key: string): boolean;
+    get<T = any | undefined>(key: string, defaultValue?: any): T;
+    getOne<T = any | undefined>(keys: string[], defaultValue?: any): T;
+    set(key: string, value: any, source?: string): void;
+    unset(key: string): void;
+    clear(): void;
+    dump(): Record<string, any>;
+}
+export {};

package/dist/client/src/shared/services/ConfigService.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/src/shared/services/ContainerService.d.ts

@@ -0,0 +1,17 @@
+type Constructor<T = object> = new (...args: any[]) => T;
+type EntryKey = string | symbol | Constructor;
+export default class ContainerService {
+    private entries;
+    loadFromRecord(record: Record<string, any>): void;
+    toRecord(): Record<string, any>;
+    private getKey;
+    set(payload: EntryKey, value: any): this;
+    has(payload: EntryKey): boolean;
+    get<T>(payload: EntryKey): T;
+    unset(payload: EntryKey): void;
+    singleton<T>(classConstructor: Constructor<T>): T;
+    load(entries: Record<any, any>): void;
+    proxy<T = unknown>(key: EntryKey): T;
+    keys(): EntryKey[];
+}
+export {};

package/dist/client/src/shared/services/EmmitterService.d.ts

@@ -0,0 +1,53 @@
+import { default as LoggerService } from './LoggerService.ts';
+export interface EmmitterListenerOptions {
+    event: string;
+}
+export interface EmmitterListener {
+    (data: any, options: EmmitterListenerOptions): void;
+}
+interface EmmitterHandler {
+    id: string;
+    event: string;
+    listener: EmmitterListener;
+    originalListener?: EmmitterListener;
+}
+interface OnOptions {
+    id?: string;
+    unique?: boolean;
+}
+interface OnDebounceOptions extends OnOptions {
+    debounce?: number;
+}
+export interface EmmitterServiceOptions {
+    debug?: boolean;
+    logger?: LoggerService;
+}
+export default class EmmitterService<Events extends Record<string, any> = Record<string, any>> {
+    static __container_entry_key: string;
+    handlers: EmmitterHandler[];
+    debug: boolean;
+    logger: LoggerService;
+    constructor(options?: EmmitterServiceOptions);
+    static create<Events extends Record<string, any> = Record<string, any>>(options?: EmmitterServiceOptions): EmmitterService<Events>;
+    setDebug(debug: boolean): void;
+    setLogger(logger: LoggerService): void;
+    on<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;
+    on(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;
+    once<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler;
+    once(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler;
+    onDebounce<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnDebounceOptions): EmmitterHandler;
+    onDebounce(event: string, listener: (args: any) => void, options?: OnDebounceOptions): EmmitterHandler;
+    onAnyOf<K extends keyof Events>(events: K[], listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler[];
+    onAnyOf(events: string[], listener: (args: any) => void, options?: OnOptions): EmmitterHandler[];
+    off(event: string, listener: EmmitterHandler['listener']): void;
+    emit<K extends keyof Events>(event: K, args: Events[K]): void;
+    emit(event: string, args?: any): void;
+    emitAndWait<K extends keyof Events>(event: K, args: Events[K]): Promise<void>;
+    emitAndWait(event: string, args?: any): Promise<void>;
+    list(): EmmitterHandler[];
+    listByEvent(event: string): EmmitterHandler[];
+    remove(payload: string | string[]): void;
+    clear(): void;
+    hasHandlers(): boolean;
+}
+export {};

package/dist/client/src/shared/services/LifecycleService.d.ts

@@ -0,0 +1,41 @@
+import { default as LoggerService } from './LoggerService.ts';
+import { default as LifecycleHook } from '../entities/LifecycleHook.ts';
+import { Constructor } from '../utils/compose.ts';
+type LifecycleMethod = 'register' | 'load' | 'boot' | 'shutdown';
+interface ListOptions {
+    include?: string | string[];
+    exclude?: string | string[];
+}
+export interface LifecycleServiceOptions {
+    debug?: boolean;
+    hooks?: Map<string, LifecycleHook>;
+    logger?: LoggerService;
+    onError?: (error: Error, context: {
+        hookId: string;
+        method: LifecycleMethod;
+    }) => void;
+}
+export default class LifecycleService {
+    static __container_entry_key: string;
+    hooks: Map<string, LifecycleHook>;
+    logger: LoggerService;
+    debug: boolean;
+    constructor(data?: LifecycleServiceOptions);
+    setOnError(handler: Required<LifecycleServiceOptions>['onError']): void;
+    onError(error: Error, context: {
+        hookId: string;
+        method: LifecycleMethod;
+    }): void;
+    mapAliases(args: string[]): string[];
+    list(options?: ListOptions): LifecycleHook[];
+    add(...payload: (LifecycleHook | Constructor<LifecycleHook>)[]): void;
+    emitMethod(method: LifecycleMethod, options?: ListOptions): Promise<void>;
+    emit(payload: LifecycleMethod | LifecycleMethod[], options?: ListOptions): Promise<void>;
+    on(method: LifecycleMethod, handler: () => Promise<void>): void;
+    register(options?: ListOptions): Promise<void>;
+    load(options?: ListOptions): Promise<void>;
+    boot(options?: ListOptions): Promise<void>;
+    shutdown(options?: ListOptions): Promise<void>;
+    clear(): void;
+}
+export {};

package/dist/client/src/shared/services/LoggerService.d.ts

@@ -0,0 +1,8 @@
+export default class LoggerService {
+    static __container_entry_key: string;
+    info(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    error(message: string | Error, meta?: any): void;
+    child(options: any): LoggerService;
+}