@luminix/core 0.0.1-beta.9 → 0.1.0-beta.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@luminix/core",
-  "version": "0.0.1-beta.9",
+  "version": "0.1.0-beta.0",
   "description": "> Projeto em desenvolvimento",
-  "main": "dist/core.js",
-  "types": "dist/index.d.ts",
+  "module": "dist/core.js",
+  "types": "types/index.d.ts",
   "type": "module",
   "scripts": {
+    "prebuild": "rm -rf types",
     "build": "tsc && vite build",
     "lint": "eslint ./src ./tests --ext .ts",
     "lint:fix": "eslint ./src ./tests --ext .ts --fix",
@@ -18,22 +19,17 @@
   "license": "MIT",
   "devDependencies": {
     "@types/jest": "^29.5.12",
-    "@types/lodash": "^4.14.202",
-    "@types/object-path": "^0.11.4",
     "@typescript-eslint/eslint-plugin": "^7.1.0",
     "@typescript-eslint/parser": "^7.1.0",
     "eslint": "^8.57.0",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
-    "nanoevents": "^9.0.0",
     "ts-jest": "^29.1.2",
     "typescript": "^5.3.3",
     "vite": "^5.0.12",
     "vite-plugin-dts": "^4.0.0-beta.1"
   },
   "peerDependencies": {
-    "axios": "^1.6.4",
-    "immer": "^10.0.3",
-    "lodash": "^4.17.21"
+    "@luminix/support": "^0.0.1-beta.7"
   }
 }

package/types/contracts/Builder.d.ts

@@ -0,0 +1,46 @@
+import { Collection, EventSource, JsonValue } from '@luminix/support';
+import { BuilderEventMap as BuilderEvents, BuilderInterface as BuilderBase, ExtendedOperator } from '../types/Builder';
+import { Model, ModelPaginatedResponse, ModelQuery } from '../types/Model';
+import { ModelFacade } from '../types/App';
+import { RouteFacade } from '../types/Route';
+import { ConfigFacade } from '../types/Config';
+type BuilderInterface = BuilderBase<Model, ModelPaginatedResponse>;
+type BuilderEventMap = BuilderEvents<Model, ModelPaginatedResponse>;
+declare class Builder extends EventSource<BuilderEventMap> implements BuilderInterface {
+    protected services: {
+        config: ConfigFacade;
+        model: ModelFacade;
+        route: RouteFacade;
+    };
+    protected abstract: string;
+    protected query: ModelQuery;
+    private bag;
+    constructor(services: {
+        config: ConfigFacade;
+        model: ModelFacade;
+        route: RouteFacade;
+    }, abstract: string, query?: ModelQuery);
+    lock(path: string): void;
+    whereBetween(key: string, value: [JsonValue, JsonValue]): this;
+    whereNotBetween(key: string, value: [JsonValue, JsonValue]): this;
+    whereNull(key: string): this;
+    whereNotNull(key: string): this;
+    limit(value: number): this;
+    where(scope: (builder: BuilderInterface) => BuilderInterface | void): this;
+    where(key: string, value: JsonValue): this;
+    where(key: string, operator: ExtendedOperator, value: JsonValue): this;
+    with(relation: string | string[]): this;
+    withOnly(relation: string | string[]): this;
+    without(relation: string | string[]): this;
+    orderBy(column: string, direction?: 'asc' | 'desc'): this;
+    searchBy(term: string): this;
+    minified(): this;
+    unset(key: string): this;
+    include(searchParams: URLSearchParams): this;
+    private exec;
+    get(page?: number, replaceLinksWith?: string): Promise<ModelPaginatedResponse>;
+    first(): Promise<Model | null>;
+    find(id: string | number): Promise<Model | null>;
+    all(): Promise<Collection<Model>>;
+}
+export default Builder;

package/types/contracts/ModelCollection.d.ts

@@ -0,0 +1,7 @@
+import { Collection } from '@luminix/support';
+import { Model } from '../types/Model';
+declare class ModelCollection extends Collection<Model> {
+    [Symbol.toStringTag]: string;
+    intersect(values: Collection<Model> | Model[]): Collection<Model>;
+}
+export default ModelCollection;

package/{dist → types}/contracts/Plugin.d.ts

@@ -1,8 +1,8 @@
-import { AppFacade, AppFacades } from '../types/App';
-
+import { AppFacade, AppContainers } from '../types/App';
+/** @deprecated */
 export default abstract class Plugin {
     readonly name?: string;
     readonly version?: string;
     register(_app: AppFacade): void;
-    boot(_facades: AppFacades): void;
+    boot(_facades: AppContainers): void;
 }

package/{dist → types}/contracts/Relation/BelongsTo.d.ts

@@ -1,15 +1,13 @@
-import { default as Relation } from '../Relation';
+import { default as Relation, RelationServices } from '../Relation';
 import { Model, ModelPaginatedResponse, RelationMetaData } from '../../types/Model';
-import { AppFacades } from '../../types/App';
 import { BuilderInterface as Builder } from '../../types/Builder';
-
 type BuilderInterface = Builder<Model, ModelPaginatedResponse>;
 export default class BelongsTo extends Relation {
+    protected services: RelationServices;
     protected meta: RelationMetaData;
-    protected facades: AppFacades;
     protected parent: Model;
     protected items: Model | null;
-    constructor(meta: RelationMetaData, facades: AppFacades, parent: Model, items?: Model | null);
+    constructor(services: RelationServices, meta: RelationMetaData, parent: Model, items?: Model | null);
     isSingle(): boolean;
     isMultiple(): boolean;
     query(): BuilderInterface;

package/{dist → types}/contracts/Relation/BelongsToMany.d.ts

@@ -1,25 +1,23 @@
-import { default as Relation } from '../Relation';
+import { Collection } from '@luminix/support';
+import { default as Relation, RelationServices } from '../Relation';
 import { Model, ModelPaginatedResponse, RelationMetaData } from '../../types/Model';
-import { AppFacades } from '../../types/App';
 import { BuilderInterface as Builder } from '../../types/Builder';
-import { Collection as CollectionInterface } from '../../types/Collection';
 import { JsonObject } from '../../types/Support';
-
 type BuilderInterface = Builder<Model, ModelPaginatedResponse>;
 export default class BelongsToMany extends Relation {
+    protected services: RelationServices;
     protected meta: RelationMetaData;
-    protected facades: AppFacades;
     protected parent: Model;
-    protected items: CollectionInterface<Model> | null;
-    constructor(meta: RelationMetaData, facades: AppFacades, parent: Model, items?: CollectionInterface<Model> | null);
+    protected items: Collection<Model> | null;
+    constructor(services: RelationServices, meta: RelationMetaData, parent: Model, items?: Collection<Model> | null);
     isSingle(): boolean;
     isMultiple(): boolean;
     query(): BuilderInterface;
     get(page?: number, replaceLinksWith?: string): Promise<ModelPaginatedResponse>;
-    all(): Promise<CollectionInterface<Model>>;
+    all(): Promise<Collection<Model>>;
     first(): Promise<Model | null>;
     find(id: string | number): Promise<Model | null>;
-    attachQuietly(id: string | number, pivot?: JsonObject): Promise<import('axios').AxiosResponse<any, any>>;
+    attachQuietly(id: string | number, pivot?: JsonObject): Promise<import('@luminix/support').Response<unknown, any>>;
     attach(id: string | number, pivot?: JsonObject): Promise<void>;
     detachQuietly(id: string | number): Promise<void>;
     detach(id: string | number): Promise<void>;

package/{dist → types}/contracts/Relation/HasMany.d.ts

@@ -1,18 +1,17 @@
-import { AppFacades } from '../../types/App';
+import { Collection } from '@luminix/support';
 import { Model, RelationMetaData } from '../../types/Model';
 import { default as HasOneOrMany } from './HasOneOrMany';
-import { Collection as CollectionInterface } from '../../types/Collection';
-
+import { RelationServices } from '../Relation';
 export default class HasMany extends HasOneOrMany {
+    protected services: RelationServices;
     protected meta: RelationMetaData;
-    protected facades: AppFacades;
     protected parent: Model;
-    protected items: CollectionInterface<Model> | null;
-    constructor(meta: RelationMetaData, facades: AppFacades, parent: Model, items?: CollectionInterface<Model> | null);
+    protected items: Collection<Model> | null;
+    constructor(services: RelationServices, meta: RelationMetaData, parent: Model, items?: Collection<Model> | null);
     isSingle(): boolean;
     isMultiple(): boolean;
     get(page?: number, replaceLinksWith?: string): Promise<import('../../types/Model').ModelPaginatedResponse>;
-    all(): Promise<CollectionInterface<Model>>;
+    all(): Promise<Collection<Model>>;
     first(): Promise<Model | null>;
     find(id: string | number): Promise<Model | null>;
     saveManyQuietly(models: Model[]): Promise<void>;

package/{dist → types}/contracts/Relation/HasOne.d.ts

@@ -1,13 +1,12 @@
 import { Model, RelationMetaData } from '../../types/Model';
-import { AppFacades } from '../../types/App';
 import { default as HasOneOrMany } from './HasOneOrMany';
-
+import { RelationServices } from '../Relation';
 export default class HasOne extends HasOneOrMany {
+    protected services: RelationServices;
     protected meta: RelationMetaData;
-    protected facades: AppFacades;
     protected parent: Model;
     protected items: Model | null;
-    constructor(meta: RelationMetaData, facades: AppFacades, parent: Model, items?: Model | null);
+    constructor(services: RelationServices, meta: RelationMetaData, parent: Model, items?: Model | null);
     isSingle(): boolean;
     isMultiple(): boolean;
     get(): Promise<Model | null>;

package/{dist → types}/contracts/Relation/HasOneOrMany.d.ts

@@ -1,7 +1,6 @@
 import { BuilderInterface as Builder } from '../../types/Builder';
 import { Model, ModelPaginatedResponse } from '../../types/Model';
 import { default as Relation } from '../Relation';
-
 type BuilderInterface = Builder<Model, ModelPaginatedResponse>;
 export default class HasOneOrMany extends Relation {
     query(): BuilderInterface;

package/{dist → types}/contracts/Relation/MorphMany.d.ts

@@ -1,18 +1,17 @@
-import { AppFacades } from '../../types/App';
+import { Collection } from '@luminix/support';
 import { Model, RelationMetaData } from '../../types/Model';
 import { default as MorphOneOrMany } from './MorphOneOrMany';
-import { Collection as CollectionInterface } from '../../types/Collection';
-
+import { RelationServices } from '../Relation';
 export default class MorphMany extends MorphOneOrMany {
+    protected services: RelationServices;
     protected meta: RelationMetaData;
-    protected facades: AppFacades;
     protected parent: Model;
-    protected items: CollectionInterface<Model> | null;
-    constructor(meta: RelationMetaData, facades: AppFacades, parent: Model, items?: CollectionInterface<Model> | null);
+    protected items: Collection<Model> | null;
+    constructor(services: RelationServices, meta: RelationMetaData, parent: Model, items?: Collection<Model> | null);
     isSingle(): boolean;
     isMultiple(): boolean;
     get(page?: number, replaceLinksWith?: string): Promise<import('../../types/Model').ModelPaginatedResponse>;
-    all(): Promise<CollectionInterface<Model>>;
+    all(): Promise<Collection<Model>>;
     first(): Promise<Model | null>;
     find(id: string | number): Promise<Model | null>;
     saveManyQuietly(models: Model[]): Promise<void>;

package/{dist → types}/contracts/Relation/MorphOne.d.ts

@@ -1,13 +1,12 @@
-import { AppFacades } from '../../types/App';
 import { Model, RelationMetaData } from '../../types/Model';
 import { default as MorphOneOrMany } from './MorphOneOrMany';
-
+import { RelationServices } from '../Relation';
 export default class MorphOne extends MorphOneOrMany {
+    protected services: RelationServices;
     protected meta: RelationMetaData;
-    protected facades: AppFacades;
     protected parent: Model;
     protected items: Model | null;
-    constructor(meta: RelationMetaData, facades: AppFacades, parent: Model, items?: Model | null);
+    constructor(services: RelationServices, meta: RelationMetaData, parent: Model, items?: Model | null);
     isSingle(): boolean;
     isMultiple(): boolean;
     get(): Promise<Model | null>;

package/{dist → types}/contracts/Relation/MorphOneOrMany.d.ts

@@ -1,7 +1,6 @@
 import { BuilderInterface as Builder } from '../../types/Builder';
 import { Model, ModelPaginatedResponse } from '../../types/Model';
 import { default as HasOneOrMany } from './HasOneOrMany';
-
 type BuilderInterface = Builder<Model, ModelPaginatedResponse>;
 export default class MorphOneOrMany extends HasOneOrMany {
     query(): BuilderInterface;

package/{dist → types}/contracts/Relation/MorphTo.d.ts

@@ -1,6 +1,5 @@
 import { Model } from '../../types/Model';
 import { default as BelongsTo } from './BelongsTo';
-
 export default class MorphTo extends BelongsTo {
     getRelated(): typeof Model;
     associate(item: Model): Promise<void>;

package/types/contracts/Relation/MorphToMany.d.ts

@@ -0,0 +1,8 @@
+import { BuilderInterface as Builder } from '../../types/Builder';
+import { Model, ModelPaginatedResponse } from '../../types/Model';
+import { default as BelongsToMany } from './BelongsToMany';
+type BuilderInterface = Builder<Model, ModelPaginatedResponse>;
+export default class MorphToMany extends BelongsToMany {
+    query(): BuilderInterface;
+}
+export {};

package/{dist → types}/contracts/Relation.d.ts

@@ -1,23 +1,26 @@
-import { AppFacades } from '../types/App';
+import { Collection, JsonValue } from '@luminix/support';
 import { BaseModel, Model, ModelPaginatedResponse, RelationMetaData } from '../types/Model';
 import { BuilderInterface as Builder, Scope as ScopeBase, ExtendedOperator } from '../types/Builder';
-import { Collection as CollectionInterface } from '../types/Collection';
 import { RelationInterface as RelationBase } from '../types/Relation';
-import { JsonValue } from '../types/Support';
-
+import { ModelFacade } from '../types/App';
+import { RouteFacade } from '../types/Route';
 type RelationInterface = RelationBase<Model, ModelPaginatedResponse>;
 type BuilderInterface = Builder<Model, ModelPaginatedResponse>;
 type Scope = ScopeBase<Model, ModelPaginatedResponse>;
+export type RelationServices = {
+    model: ModelFacade;
+    route: RouteFacade;
+};
 export default class Relation implements RelationInterface {
+    protected services: RelationServices;
     protected meta: RelationMetaData;
-    protected facades: AppFacades;
     protected parent: BaseModel;
-    protected items: Model | CollectionInterface<Model> | null;
+    protected items: Model | Collection<Model> | null;
     private unsubscribeQuery;
-    constructor(meta: RelationMetaData, facades: AppFacades, parent: BaseModel, items?: Model | CollectionInterface<Model> | null);
+    constructor(services: RelationServices, meta: RelationMetaData, parent: BaseModel, items?: Model | Collection<Model> | null);
     make(data: JsonValue): void;
     guessInverseRelation(): string;
-    set(items: Model | CollectionInterface<Model> | null): void;
+    set(items: Model | Collection<Model> | null): void;
     getForeignKey(): string | null;
     getName(): string;
     getType(): "HasOne" | "HasMany" | "BelongsTo" | "BelongsToMany" | "MorphOne" | "MorphMany" | "MorphTo" | "MorphToMany" | "MorphedByMany";
@@ -25,7 +28,7 @@ export default class Relation implements RelationInterface {
     getRelated(): typeof Model;
     query(): Builder<Model, ModelPaginatedResponse>;
     isLoaded(): boolean;
-    getLoadedItems(): Model | CollectionInterface<Model> | null;
+    getLoadedItems(): Model | Collection<Model> | null;
     isSingle(): boolean;
     isMultiple(): boolean;
     getParent(): BaseModel;

package/types/facades/App.d.ts

@@ -0,0 +1,12 @@
+import { HasFacadeAccessor, Application, FacadeOf, MacroableInterface } from '@luminix/support';
+import { AppContainers, AppMacros } from '../types/App';
+declare module '@luminix/support' {
+    interface ApplicationInterface extends MacroableInterface<AppMacros>, AppMacros {
+    }
+}
+declare class AppFacade implements HasFacadeAccessor {
+    getFacadeAccessor(): string | object;
+    down(): void;
+}
+declare const App: FacadeOf<Application<AppContainers> & AppMacros & MacroableInterface<AppMacros>, AppFacade>;
+export default App;

package/types/facades/Auth.d.ts

@@ -0,0 +1,7 @@
+import { HasFacadeAccessor } from '@luminix/support';
+import { default as AuthService } from '../services/AuthService';
+declare class AuthFacade implements HasFacadeAccessor {
+    getFacadeAccessor(): string | object;
+}
+declare const Auth: import('@luminix/support').FacadeOf<AuthService, AuthFacade>;
+export default Auth;

package/types/facades/Config.d.ts

@@ -0,0 +1,7 @@
+import { HasFacadeAccessor, PropertyBag } from '@luminix/support';
+import { AppConfiguration } from '../types/Config';
+declare class ConfigFacade implements HasFacadeAccessor {
+    getFacadeAccessor(): string | object;
+}
+declare const Config: import('@luminix/support').FacadeOf<PropertyBag<AppConfiguration>, ConfigFacade>;
+export default Config;

package/types/facades/Error.d.ts

@@ -0,0 +1,10 @@
+import { HasFacadeAccessor, Response } from '@luminix/support';
+import { ValidationError } from '../types/Error';
+import { default as ErrorService } from '../services/ErrorService';
+/** @deprecated */
+export declare const isValidationError: (response: unknown) => response is Response<ValidationError, any>;
+declare class ErrorFacade implements HasFacadeAccessor {
+    getFacadeAccessor(): string | object;
+}
+declare const Error: import('@luminix/support').FacadeOf<ErrorService, ErrorFacade>;
+export default Error;

package/types/facades/Http.d.ts

@@ -0,0 +1,8 @@
+import { HasFacadeAccessor } from '@luminix/support';
+import { HttpService } from '../services/HttpService';
+import { HttpMacro } from '../types/Http';
+declare class HttpFacade implements HasFacadeAccessor {
+    getFacadeAccessor(): string | object;
+}
+declare const Http: import('@luminix/support').FacadeOf<HttpService, HttpFacade & Record<string, HttpMacro> & import('@luminix/support').MacroableInterface<Record<string, HttpMacro>> & HasFacadeAccessor>;
+export default Http;

package/types/facades/Log.d.ts

@@ -0,0 +1,7 @@
+import { HasFacadeAccessor } from '@luminix/support';
+import { default as LogService } from '../services/LogService';
+declare class LogFacade implements HasFacadeAccessor {
+    getFacadeAccessor(): string | object;
+}
+declare const Log: import('@luminix/support').FacadeOf<LogService, LogFacade>;
+export default Log;

package/types/facades/Model.d.ts

@@ -0,0 +1,8 @@
+import { HasFacadeAccessor, ReducibleInterface } from '@luminix/support';
+import { ModelService } from '../services/ModelService';
+import { ModelReducers } from '../types/Model';
+declare class ModelFacade implements HasFacadeAccessor {
+    getFacadeAccessor(): string | object;
+}
+declare const Model: import('@luminix/support').FacadeOf<ModelService & ModelReducers & ReducibleInterface<ModelReducers>, ModelFacade>;
+export default Model;

package/types/facades/Route.d.ts

@@ -0,0 +1,7 @@
+import { HasFacadeAccessor } from '@luminix/support';
+import { RouteService } from '../services/RouteService';
+declare class RouteFacade implements HasFacadeAccessor {
+    getFacadeAccessor(): string | object;
+}
+declare const Route: import('@luminix/support').FacadeOf<RouteService, RouteFacade>;
+export default Route;

package/types/helpers/app.d.ts

@@ -0,0 +1,4 @@
+import { AppContainers, AppFacade } from '../types/App';
+declare function app(): AppFacade;
+declare function app<T extends keyof AppContainers>(facade: T): AppContainers[T];
+export default app;

package/{dist → types}/helpers/auth.d.ts

@@ -1,3 +1,2 @@
 import { AuthFacade } from '../types/Auth';
-
 export default function (): AuthFacade;

package/types/helpers/collect.d.ts

@@ -0,0 +1,2 @@
+import { Collection } from '@luminix/support';
+export default function collect<T = unknown>(items: T[]): Collection<T>;

package/{dist → types}/helpers/config.d.ts

@@ -1,5 +1,4 @@
 import { ConfigFacade } from '../types/Config';
-
 declare function config(): ConfigFacade;
 declare function config(path: string, defaultValue?: unknown): unknown;
 export default config;

package/{dist → types}/helpers/error.d.ts

@@ -1,4 +1,3 @@
 import { ErrorFacade } from '../types/Error';
-
 export default function error(): ErrorFacade;
 export default function error(key: string, bag?: string): string | null;

package/types/helpers/log.d.ts

@@ -0,0 +1,5 @@
+import { LogFacade } from '../types/Log';
+import { FacadeOf, HasFacadeAccessor } from '@luminix/support';
+declare function log(): FacadeOf<LogFacade, HasFacadeAccessor>;
+declare function log(...data: any[]): void;
+export default log;

package/{dist → types}/helpers/model.d.ts

@@ -1,6 +1,5 @@
 import { Model } from '../types/Model';
-import { ModelFacade } from '../types/App';
-
-declare function model(): ModelFacade;
+import { AppContainers } from '../types/App';
+declare function model(): AppContainers['model'];
 declare function model(abstract: string): typeof Model;
 export default model;

package/{dist → types}/helpers/route.d.ts

@@ -1,5 +1,5 @@
 import { RouteFacade, RouteReplacer } from '../types/Route';
-
-declare function route(): RouteFacade;
+import { FacadeOf, HasFacadeAccessor } from '@luminix/support';
+declare function route(): FacadeOf<RouteFacade, HasFacadeAccessor>;
 declare function route(name: string, parameters?: RouteReplacer): string;
 export default route;

package/{dist → types}/index.d.ts

@@ -6,19 +6,19 @@ import { default as error } from './helpers/error';
 import { default as log } from './helpers/log';
 import { default as model } from './helpers/model';
 import { default as route } from './helpers/route';
-import { isValidationError } from './facades/Error';
+import { default as App } from './facades/App';
+import { default as Auth } from './facades/Auth';
+import { default as Config } from './facades/Config';
+import { default as Error, isValidationError } from './facades/Error';
+import { default as Http } from './facades/Http';
+import { default as Log } from './facades/Log';
+import { default as Model } from './facades/Model';
+import { default as Route } from './facades/Route';
 import { default as Plugin } from './contracts/Plugin';
-import { default as PropertyBag } from './contracts/PropertyBag';
 import { isModel } from './support/model';
-import { isCollection } from './support/collection';
-import { Reducible } from './mixins/Reducible';
-import { HasEvents } from './mixins/HasEvents';
-
-export { app, auth, collect, config, error, log, model, route, isCollection, isValidationError, isModel, Plugin, PropertyBag, Reducible, HasEvents, };
+export { app, App, auth, Auth, collect, config, Config, error, Error, Http, log, Log, model, Model, route, Route, isValidationError, isModel, Plugin, };
 export type { AppFacade } from './types/App';
 export type { AuthFacade } from './types/Auth';
 export type { LogFacade } from './types/Log';
-export type { ReducibleInterface } from './types/Reducer';
 export type { RouteFacade } from './types/Route';
-export type { Model, BaseModel } from './types/Model';
-export type { EventSource } from './types/Event';
+export type { Model as ModelType, BaseModel } from './types/Model';

package/types/mixins/BaseModel.d.ts

@@ -0,0 +1,7 @@
+import { BaseModel, Model as ModelInterface } from '../types/Model';
+import { ModelFacade } from '../types/App';
+import { RouteFacade } from '../types/Route';
+import { LogFacade } from '../types/Log';
+import { ConfigFacade } from '../types/Config';
+export declare function BaseModelFactory(Config: ConfigFacade, Log: LogFacade, ModelFacade: ModelFacade, Route: RouteFacade, abstract: string): typeof BaseModel;
+export declare function ModelFactory(ModelFacade: ModelFacade, abstract: string, CustomModel: typeof BaseModel): typeof ModelInterface;

package/types/providers/LuminixServiceProvider.d.ts

@@ -0,0 +1,9 @@
+import { ServiceProvider } from '@luminix/support';
+export default class LuminixServiceProvider extends ServiceProvider {
+    protected flushReady?: () => void;
+    register(): void;
+    boot(): void;
+    flush(): void;
+    registerServices(): void;
+    registerMacros(): void;
+}

package/types/services/AuthService.d.ts

@@ -0,0 +1,18 @@
+import { PropertyBag } from '@luminix/support';
+import { AuthCredentials } from '../types/Auth';
+import { Model } from '../types/Model';
+import { AppConfiguration } from '../types/Config';
+import { ModelFacade } from '../types/App';
+import { RouteFacade } from '../types/Route';
+export default class AuthService {
+    protected config: PropertyBag<AppConfiguration>;
+    protected model: ModelFacade;
+    protected route: RouteFacade;
+    protected _user: Model | undefined;
+    constructor(config: PropertyBag<AppConfiguration>, model: ModelFacade, route: RouteFacade);
+    attempt(credentials: AuthCredentials, remember?: boolean, onSubmit?: (e: Event) => void): void;
+    check(): boolean;
+    logout(onSubmit?: (e: Event) => void): void;
+    user(): Model | undefined;
+    id(): number | string | null;
+}

package/{dist/facades/Error.d.ts → types/services/ErrorService.d.ts}

@@ -1,8 +1,5 @@
-import { default as PropertyBag } from '../contracts/PropertyBag';
-import { ErrorFacade, ValidationError } from '../types/Error';
-
-export declare const isValidationError: (error: unknown) => error is ValidationError;
-declare class Error implements ErrorFacade {
+import { PropertyBag } from '@luminix/support';
+export default class ErrorService {
     private bags;
     constructor();
     bag(name?: string): PropertyBag<Record<string, string>>;
@@ -12,4 +9,3 @@ declare class Error implements ErrorFacade {
     get(key: string, bag?: string): string | null;
     clear(bag?: string): void;
 }
-export default Error;

package/types/services/HttpService.d.ts

@@ -0,0 +1,21 @@
+import { Client, RequestOptions } from '@luminix/support';
+export declare class HttpService {
+    getClient(): Client;
+    baseUrl(baseUrl: string): Client;
+    asForm(): Client;
+    accept(type: string): Client;
+    acceptJson(): Client;
+    withHeaders(headers: Record<string, string>): Client;
+    withOptions(options: RequestOptions): Client;
+    withData(data: object): Client;
+    withQueryParameters(params: string | object): Client;
+    withBasicAuth(username: string, password: string): Client;
+    withToken(token: string): Client;
+    get<TResponse = any>(url: string, query?: string | object): import('@luminix/support').Request<TResponse, any>;
+    post<TResponse = any, TData = any>(url: string, data?: TData): import('@luminix/support').Request<TResponse, TData>;
+    put<TResponse = any, TData = any>(url: string, data?: TData): import('@luminix/support').Request<TResponse, TData>;
+    patch<TResponse = any, TData = any>(url: string, data?: TData): import('@luminix/support').Request<TResponse, TData>;
+    delete<TResponse = any>(url: string, query?: string | object): import('@luminix/support').Request<TResponse, any>;
+}
+declare const _default: import('@luminix/support').MacroableOf<typeof HttpService, Record<string, (...args: any) => Client>>;
+export default _default;

package/{dist/facades/Log.d.ts → types/services/LogService.d.ts}

@@ -1,7 +1,5 @@
-import { LogFacade } from '../types/Log';
-
-export default class Log implements LogFacade {
-    private _debug;
+export default class LogService {
+    protected _debug: boolean;
     constructor(_debug: boolean);
     emergency(...args: any[]): void;
     alert(...args: any[]): void;

package/types/services/ModelService.d.ts

@@ -0,0 +1,21 @@
+import { EventSource } from '@luminix/support';
+import { ModelSchema, ModelSchemaAttributes, Model, ModelReducers } from '../types/Model';
+import { AppFacade, GlobalModelEvents } from '../types/App';
+export declare class ModelService extends EventSource<GlobalModelEvents> {
+    private readonly _schema;
+    private _models;
+    [Symbol.toStringTag]: string;
+    constructor(_schema: ModelSchema);
+    boot(app: AppFacade): void;
+    schema(): ModelSchema;
+    schema(abstract: string): ModelSchemaAttributes;
+    make(): {
+        [abstract: string]: typeof Model;
+    };
+    make(abstract: string): typeof Model;
+    getRelationConstructors(abstract: string): any;
+    toString(): string;
+    [key: string]: any;
+}
+declare const _default: import('@luminix/support').ReducibleOf<typeof ModelService, ModelReducers>;
+export default _default;