@luminix/core 0.0.1-beta.0 → 0.0.1-beta.10

package/dist/exceptions/AttributeNotFillableException.d.ts

@@ -1,4 +1,4 @@
 export default class AttributeNotFillableException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(abstract: string, attribute: string);
 }

package/dist/exceptions/FacadeNotFoundException.d.ts

@@ -1,4 +1,4 @@
 export default class FacadeNotFoundException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(name: string);
 }

package/dist/exceptions/MethodNotImplementedException.d.ts

@@ -1,4 +1,4 @@
 export default class MethodNotImplementedException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor();
 }

package/dist/exceptions/ModelInvalidRelatedTypeException.d.ts

@@ -1,4 +1,4 @@
 export default class ModelInvalidRelatedTypeException extends TypeError {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(caller: string, expectedType: string, relatedType: string);
 }

package/dist/exceptions/ModelNotFoundException.d.ts

@@ -1,4 +1,4 @@
 export default class ModelNotFoundException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(model: string);
 }

package/dist/exceptions/ModelNotPersistedException.d.ts

@@ -1,4 +1,4 @@
 export default class ModelNotPersistedException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(model: string, operation: string);
 }

package/dist/exceptions/ModelWithoutPrimaryKeyException.d.ts

@@ -1,4 +1,4 @@
 export default class ModelWithoutPrimaryKeyException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(model: string);
 }

package/dist/exceptions/NoEmbedException.d.ts

@@ -1,4 +1,4 @@
 export default class NoEmbedException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor();
 }

package/dist/exceptions/NoInverseRelationException.d.ts

@@ -1,4 +1,4 @@
 export default class NoInverseRelationException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(model: string, relation: string, related: string, relatedRelation: string);
 }

package/dist/exceptions/NotModelException.d.ts

@@ -1,4 +1,4 @@
 export default class NotModelException extends TypeError {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(caller: string, expects?: string);
 }

package/dist/exceptions/NotReducibleException.d.ts

@@ -1,4 +1,4 @@
 export default class NotReducibleException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(facade: unknown);
 }

package/dist/exceptions/ReducerOverrideException.d.ts

@@ -1,4 +1,4 @@
 export default class ReducerOverrideException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(name: string, target: unknown);
 }

package/dist/exceptions/RouteNotFoundException.d.ts

@@ -1,4 +1,4 @@
 export default class RouteNotFoundException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(route: string);
 }

package/dist/exceptions/UnsupportedRelationException.d.ts

@@ -1,4 +1,4 @@
 export default class UnsupportedRelationException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(relation: string);
 }

package/dist/facades/App.d.ts

@@ -1,7 +1,9 @@
 import { AppFacades, AppFacade, AppEvents } from '../types/App';
-import Plugin from '../contracts/Plugin';
+import { default as Plugin } from '../contracts/Plugin';
 import { AppConfiguration } from '../types/Config';
 import { Unsubscribe } from 'nanoevents';
+import { Constructor } from '../types/Support';
+
 declare class App implements AppFacade {
     private facades;
     private booted;
@@ -12,19 +14,24 @@ declare class App implements AppFacade {
     bind<K extends keyof AppFacades>(key: K, facade: AppFacades[K]): void;
     plugins(): Plugin[];
     boot(configObject?: AppConfiguration): Promise<AppFacades>;
+    environment(): string;
+    environment(...environments: string[]): boolean;
+    getPlugin<T extends Plugin>(abstract: Constructor<T>): T | undefined;
+    hasDebugModeEnabled(): boolean;
+    isLocal(): boolean;
+    isProduction(): boolean;
     on<E extends keyof AppEvents>(_: E, __: AppEvents[E]): Unsubscribe;
     once<E extends keyof AppEvents>(_: E, __: AppEvents[E]): void;
     emit<E extends keyof AppEvents>(_: E, __?: Omit<Parameters<AppEvents[E]>[0], 'source'>): void;
 }
 declare const _default: {
     new (...args: any[]): {
-        "__#1@#emitter": import("nanoevents").Emitter<import("../types/Event").EventSourceEvents>;
-        "__#1@#createNanoEvents"(): import("nanoevents").Emitter<import("../types/Event").EventSourceEvents>;
+        emitter: import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
+        "__#1@#createNanoEvents"(): import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
         on<E extends keyof AppEvents>(event: E, callback: AppEvents[E]): Unsubscribe;
         once<E_1 extends keyof AppEvents>(event: E_1, callback: AppEvents[E_1]): void;
         emit<E_2 extends keyof AppEvents>(event: E_2, data?: Omit<Parameters<AppEvents[E_2]>[0], "source">): void;
         [Symbol.toStringTag]: string;
     };
-    name: string;
 } & typeof App;
 export default _default;

package/dist/facades/Auth.d.ts

@@ -1,6 +1,7 @@
 import { AppFacade } from '../types/App';
 import { AuthCredentials, AuthFacade } from '../types/Auth';
 import { Model } from '../types/Model';
+
 export default class Auth implements AuthFacade {
     private readonly app;
     private _user;

package/dist/facades/Error.d.ts

@@ -1,5 +1,6 @@
-import PropertyBag from '../contracts/PropertyBag';
+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 {
     private bags;

package/dist/facades/Log.d.ts

@@ -1,4 +1,5 @@
 import { LogFacade } from '../types/Log';
+
 export default class Log implements LogFacade {
     private _debug;
     constructor(_debug: boolean);

package/dist/facades/Model.d.ts

@@ -3,10 +3,11 @@ import { AppFacade, GlobalModelEvents, ModelFacade as ModelFacadeInterface } fro
 import { Unsubscribe } from 'nanoevents';
 import { Reducer, ReducerCallback, Unsubscribe as UnsubscribeReducer } from '../types/Reducer';
 import { Collection } from '../contracts/Collection';
+
 declare class ModelFacade implements ModelFacadeInterface {
     private readonly _schema;
     private _models;
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(_schema: ModelSchema);
     boot(app: AppFacade): void;
     schema(): ModelSchema;
@@ -29,13 +30,12 @@ declare class ModelFacade implements ModelFacadeInterface {
 }
 declare const _default: {
     new (...args: any[]): {
-        "__#1@#emitter": import("nanoevents").Emitter<import("../types/Event").EventSourceEvents>;
-        "__#1@#createNanoEvents"(): import("nanoevents").Emitter<import("../types/Event").EventSourceEvents>;
+        emitter: import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
+        "__#1@#createNanoEvents"(): import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
         on<E extends keyof GlobalModelEvents>(event: E, callback: GlobalModelEvents[E]): Unsubscribe;
         once<E_1 extends keyof GlobalModelEvents>(event: E_1, callback: GlobalModelEvents[E_1]): void;
         emit<E_2 extends keyof GlobalModelEvents>(event: E_2, data?: Omit<Parameters<GlobalModelEvents[E_2]>[0], "source">): void;
         [Symbol.toStringTag]: string;
     };
-    name: string;
 } & typeof ModelFacade;
 export default _default;

package/dist/facades/Route.d.ts

@@ -1,5 +1,6 @@
 import { RouteDefinition, RouteTuple as RouteTuple, HttpMethod, RouteGenerator, RouteCallConfig } from '../types/Route';
 import { ErrorFacade } from '../types/Error';
+
 declare class Route {
     private routes;
     private error;
@@ -11,18 +12,18 @@ declare class Route {
     url(generator: RouteGenerator): string;
     methods(generator: RouteGenerator): HttpMethod[];
     exists(name: string): boolean;
-    call(generator: RouteGenerator, config?: RouteCallConfig): Promise<import("axios").AxiosResponse<any, any>>;
+    call(generator: RouteGenerator, config?: RouteCallConfig): Promise<import('axios').AxiosResponse<any, any>>;
     toString(): string;
     [reducer: string]: unknown;
 }
 declare const _default: {
     new (...args: any[]): {
         reducers: {
-            [name: string]: import("../types/Collection").Collection<import("../types/Reducer").Reducer>;
+            [name: string]: import('../types/Collection').Collection<import('../types/Reducer').Reducer>;
         };
-        reducer(name: string, callback: import("../types/Reducer").ReducerCallback, priority?: number): () => void;
-        removeReducer(name: string, callback: import("../types/Reducer").ReducerCallback): void;
-        getReducer(name: string): import("../types/Collection").Collection<import("../types/Reducer").Reducer>;
+        reducer(name: string, callback: import('../types/Reducer').ReducerCallback, priority?: number): () => void;
+        removeReducer(name: string, callback: import('../types/Reducer').ReducerCallback): void;
+        getReducer(name: string): import('../types/Collection').Collection<import('../types/Reducer').Reducer>;
         hasReducer(name: string): boolean;
         clearReducer(name: string): void;
         flushReducers(): void;

package/dist/helpers/app.d.ts

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

package/dist/helpers/auth.d.ts

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

package/dist/helpers/collect.d.ts

@@ -1 +1 @@
-export default function collect<T = unknown>(items: T[]): import("../types/Collection").Collection<T>;
+export default function collect<T = unknown>(items: T[]): import('../types/Collection').Collection<T>;

package/dist/helpers/config.d.ts

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

package/dist/helpers/error.d.ts

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

package/dist/helpers/log.d.ts

@@ -1,4 +1,5 @@
 import { LogFacade } from '../types/Log';
+
 declare function log(): LogFacade;
 declare function log(...data: any[]): void;
 export default log;

package/dist/helpers/model.d.ts

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

package/dist/helpers/route.d.ts

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

package/dist/index.d.ts

@@ -1,18 +1,19 @@
-import app from './helpers/app';
-import auth from './helpers/auth';
-import collect from './helpers/collect';
-import config from './helpers/config';
-import error from './helpers/error';
-import log from './helpers/log';
-import model from './helpers/model';
-import route from './helpers/route';
+import { default as app } from './helpers/app';
+import { default as auth } from './helpers/auth';
+import { default as collect } from './helpers/collect';
+import { default as config } from './helpers/config';
+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 Plugin from './contracts/Plugin';
-import PropertyBag from './contracts/PropertyBag';
+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 type { AppFacade } from './types/App';
 export type { AuthFacade } from './types/Auth';

package/dist/mixins/BaseModel.d.ts

@@ -1,4 +1,5 @@
 import { BaseModel, Model as ModelInterface } from '../types/Model';
-import { AppFacades } from '../types/App';
-export declare function BaseModelFactory(facades: AppFacades, abstract: string): typeof BaseModel;
+import { AppFacade, AppFacades } from '../types/App';
+
+export declare function BaseModelFactory(app: AppFacade, abstract: string): typeof BaseModel;
 export declare function ModelFactory(facades: AppFacades, abstract: string, CustomModel: typeof BaseModel): typeof ModelInterface;

package/dist/mixins/HasEvents.d.ts

@@ -1,15 +1,15 @@
 import { Emitter } from 'nanoevents';
 import { EventSourceEvents, EventSource } from '../types/Event';
 import { Constructor } from '../types/Support';
+
 export declare function isEventSource<T>(value: T): value is T & EventSource<any>;
 export declare function HasEvents<T extends EventSourceEvents, U extends Constructor>(Base: U): {
     new (...args: any[]): {
-        "__#1@#emitter": Emitter<EventSourceEvents>;
+        emitter: Emitter<EventSourceEvents>;
         "__#1@#createNanoEvents"(): Emitter<EventSourceEvents>;
-        on<E extends keyof T>(event: E, callback: T[E]): import("nanoevents").Unsubscribe;
+        on<E extends keyof T>(event: E, callback: T[E]): import('nanoevents').Unsubscribe;
         once<E_1 extends keyof T>(event: E_1, callback: T[E_1]): void;
         emit<E_2 extends keyof T>(event: E_2, data?: Omit<Parameters<T[E_2]>[0], "source">): void;
         [Symbol.toStringTag]: string;
     };
-    name: string;
 } & U;

package/dist/mixins/Reducible.d.ts

@@ -1,6 +1,7 @@
 import { ReducerCallback, Reducer } from '../types/Reducer';
 import { Constructor } from '../types/Support';
 import { Collection } from '../types/Collection';
+
 export declare function Reducible<T extends Constructor>(Base: T): {
     new (...args: any[]): {
         reducers: {

package/dist/support/collection.d.ts

@@ -1,3 +1,4 @@
 import { Collection } from '../types/Collection';
+
 export declare function cartesian<T>(...arrays: T[][]): T[][];
 export declare function isCollection(instance: unknown): instance is Collection;

package/dist/support/model.d.ts

@@ -1,2 +1,3 @@
 import { Model } from '../types/Model';
+
 export declare function isModel(value: unknown): value is Model;

package/dist/types/App.d.ts

@@ -7,6 +7,8 @@ import { RouteFacade } from './Route';
 import { EventSource, Event } from './Event';
 import { ErrorFacade } from './Error';
 import { ReducibleInterface } from './Reducer';
+import { Constructor } from './Support';
+
 type Plugin = PluginInterface<AppFacade, AppFacades>;
 export type GlobalModelEvents = {
     'save': (e: ModelGlobalEvent) => void;
@@ -47,6 +49,12 @@ export type AppExternal = {
     make<T extends keyof AppFacades>(key: T): AppFacades[T];
     plugins: () => Plugin[];
     on: EventSource<AppEvents>['once'];
+    environment(): string;
+    environment(...environments: string[]): boolean;
+    getPlugin<T extends Plugin>(abstract: Constructor<T>): T | undefined;
+    hasDebugModeEnabled(): boolean;
+    isLocal(): boolean;
+    isProduction(): boolean;
 };
 export type AppFacade = AppExternal & {
     has(key: string): boolean;

package/dist/types/Auth.d.ts

@@ -1,4 +1,5 @@
 import { Model } from './Model';
+
 export type AuthCredentials = {
     email: string;
     password: string;

package/dist/types/Builder.d.ts

@@ -1,7 +1,9 @@
-import PropertyBag, { PropertyBagEventMap } from '../contracts/PropertyBag';
+import { default as PropertyBag } from '../contracts/PropertyBag';
 import { Event, EventSource } from './Event';
 import { JsonObject, JsonValue } from './Support';
 import { Operator, Collection } from './Collection';
+import { PropertyBagEventMap } from './PropertyBag';
+
 export type Scope<R, C> = (builder: BuilderInterface<R, C>) => BuilderInterface<R, C> | void;
 export type ExtendedOperator = Operator | 'like' | 'notLike' | 'between' | 'notBetween' | 'isNull' | 'isNotNull';
 export type BuilderInterface<R, C> = EventSource<BuilderEventMap<R, C>> & {
@@ -10,6 +12,9 @@ export type BuilderInterface<R, C> = EventSource<BuilderEventMap<R, C>> & {
     where(key: string, value: JsonValue): BuilderInterface<R, C>;
     where(key: string, operator: ExtendedOperator, value: JsonValue): BuilderInterface<R, C>;
     where(key: string | Scope<R, C>, operatorOrValue?: ExtendedOperator | JsonValue, value?: JsonValue): BuilderInterface<R, C>;
+    with(relation: string | string[]): BuilderInterface<R, C>;
+    withOnly(relation: string | string[]): BuilderInterface<R, C>;
+    without(relation: string | string[]): BuilderInterface<R, C>;
     whereNull(key: string): BuilderInterface<R, C>;
     whereNotNull(key: string): BuilderInterface<R, C>;
     whereBetween(key: string, value: [JsonValue, JsonValue]): BuilderInterface<R, C>;
@@ -18,6 +23,7 @@ export type BuilderInterface<R, C> = EventSource<BuilderEventMap<R, C>> & {
     searchBy(term: string): BuilderInterface<R, C>;
     minified(): BuilderInterface<R, C>;
     limit(value: number): BuilderInterface<R, C>;
+    include(searchParams: URLSearchParams): BuilderInterface<R, C>;
     get(page?: number, replaceLinksWith?: string): Promise<C>;
     all(): Promise<Collection<R>>;
     first(): Promise<R | null>;

package/dist/types/Collection.d.ts

@@ -1,5 +1,6 @@
 import { Event, EventSource } from './Event';
 import { Constructor, TypeOf, JsonValue } from './Support';
+
 export type CollectionEvents<T = unknown> = {
     'change': (e: CollectionChangeEvent<T>) => void;
 };

package/dist/types/Config.d.ts

@@ -1,6 +1,7 @@
-import { PropertyBag } from '..';
+import { PropertyBag } from './PropertyBag';
 import { ModelSchema } from './Model';
 import { RouteDefinition } from './Route';
+
 export type AppConfiguration = {
     app?: {
         env?: string;

package/dist/types/Error.d.ts

@@ -1,5 +1,7 @@
-import PropertyBag, { PropertyBagEventMap } from '../contracts/PropertyBag';
+import { default as PropertyBag } from '../contracts/PropertyBag';
 import { Event, EventSource } from './Event';
+import { PropertyBagEventMap } from './PropertyBag';
+
 export type ErrorEventMap = {
     change: (e: ErrorChangeEvent) => void;
 };

package/dist/types/Event.d.ts

@@ -1,4 +1,5 @@
 import { Unsubscribe } from 'nanoevents';
+
 export type Event<S = any> = {
     source: S;
 };

package/dist/types/Model.d.ts

@@ -3,6 +3,8 @@ import { EventSource, Event } from './Event';
 import { Collection } from './Collection';
 import { RelationInterface, BuilderInterface, Scope, ExtendedOperator } from './Relation';
 import { JsonObject, JsonValue } from './Support';
+import { RouteGenerator } from './Route';
+
 export type RelationRepository = Record<string, RelationInterface<Model, ModelPaginatedResponse>>;
 export type ModelEvents = {
     'change': (e: ModelChangeEvent) => void;
@@ -44,18 +46,25 @@ export declare class BaseModel implements EventSource<ModelEvents> {
     setAttribute(key: string, value: unknown): void;
     getKey(): string | number;
     getKeyName(): string;
-    fill(attributes: JsonObject): void;
+    fill(attributes: object): void;
     toJson(): JsonObject;
     diff(): JsonObject;
     getType(): string;
     dump(): void;
-    save(options?: ModelSaveOptions): Promise<AxiosResponse<unknown, unknown>>;
+    save(options?: ModelSaveOptions): Promise<AxiosResponse | void>;
     update(attributes: JsonObject): Promise<void>;
-    delete(): Promise<AxiosResponse<unknown, unknown>>;
-    forceDelete(): Promise<AxiosResponse<unknown, unknown>>;
-    restore(): Promise<AxiosResponse<unknown, unknown>>;
+    delete(): Promise<AxiosResponse>;
+    forceDelete(): Promise<AxiosResponse>;
+    restore(): Promise<AxiosResponse>;
     refresh(): Promise<void>;
     relation(relationName: string): RelationInterface<Model, ModelPaginatedResponse> | undefined;
+    getErrorBag(method: string): string;
+    getRouteForSave(): RouteGenerator;
+    getRouteForUpdate(): RouteGenerator;
+    getRouteForDelete(): RouteGenerator;
+    getRouteForRestore(): RouteGenerator;
+    getRouteForForceDelete(): RouteGenerator;
+    getRouteForRefresh(): RouteGenerator;
     static getSchemaName(): string;
     static getSchema(): ModelSchemaAttributes;
     static query(): BuilderInterface<Model, ModelPaginatedResponse>;
@@ -90,7 +99,7 @@ export declare class BaseModel implements EventSource<ModelEvents> {
 }
 export declare class Model extends BaseModel {
     [key: string]: any;
-    static [key: string]: any;
+    [Symbol.toStringTag]: string;
 }
 export interface ModelSaveOptions {
     additionalPayload?: object;
@@ -106,6 +115,21 @@ export interface ModelTableColumnDefinition {
     sortable?: boolean;
 }
 export interface ModelSchemaAttributes {
+    attributes: {
+        appended: true | null;
+        cast: string | null;
+        default: string | null;
+        fillable: boolean;
+        hidden: boolean;
+        increments: boolean;
+        name: string;
+        nullable: boolean;
+        phpType: string | null;
+        primary: boolean;
+        type: string | null;
+        unique: boolean;
+        virtual: boolean;
+    }[];
     displayName: {
         singular: string;
         plural: string;
@@ -116,6 +140,7 @@ export interface ModelSchemaAttributes {
     primaryKey: string;
     timestamps: boolean;
     labeledBy: string;
+    [key: string]: any;
 }
 export interface RelationMetaData {
     model: string;
@@ -131,7 +156,7 @@ export type ModelQuery = JsonObject & {
     page?: number;
     per_page?: number;
     order_by?: string;
-    filters?: JsonObject;
+    where?: JsonObject;
     tab?: string;
     minified?: boolean;
 };

package/dist/types/PropertyBag.d.ts

@@ -0,0 +1,25 @@
+import { Unsubscribe } from 'nanoevents';
+import { Event } from './Event';
+
+export type PropertyBagChangeEvent<T extends object> = Event<PropertyBag<T>> & {
+    path: string;
+    value: unknown;
+    type: 'set' | 'merge' | 'delete';
+};
+export type PropertyBagEventMap<T extends object = any> = {
+    'change': (e: PropertyBagChangeEvent<T>) => void;
+};
+export type PropertyBag<T extends object> = {
+    get(path: string, defaultValue?: unknown): unknown;
+    set(path: string, value: unknown): void;
+    merge(path: string, value: unknown): void;
+    has(path: string): boolean;
+    delete(path: string): void;
+    lock(path: string): void;
+    clone(): PropertyBag<T>;
+    all(): T;
+    isEmpty(): boolean;
+    on<K extends keyof PropertyBagEventMap<T>>(event: K, callback: PropertyBagEventMap<T>[K]): Unsubscribe;
+    once<K extends keyof PropertyBagEventMap<T>>(event: K, callback: PropertyBagEventMap<T>[K]): void;
+    emit<K extends keyof PropertyBagEventMap<T>>(event: K, payload: Omit<Parameters<PropertyBagEventMap<T>[K]>[0], 'source'>): void;
+};

package/dist/types/Reducer.d.ts

@@ -1,4 +1,5 @@
 import { Collection } from './Collection';
+
 export type ReducerCallback = (value: any, ...params: any[]) => any;
 export interface Reducer {
     callback: ReducerCallback;

package/dist/types/Relation.d.ts

@@ -1,6 +1,7 @@
 import { BuilderInterface, ExtendedOperator, Scope } from './Builder';
 import { Collection } from './Collection';
 import { Constructor, JsonValue } from './Support';
+
 export type { BuilderInterface, ExtendedOperator, Scope, };
 export type RelationInterface<R, C> = {
     guessInverseRelation(): string;

package/dist/types/Route.d.ts

@@ -1,5 +1,6 @@
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { ReducibleInterface } from './Reducer';
+
 export type RouteReplacer = {
     [key: string]: string | number;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luminix/core",
-  "version": "0.0.1-beta.0",
+  "version": "0.0.1-beta.10",
   "description": "> Projeto em desenvolvimento",
   "main": "dist/core.js",
   "types": "dist/index.d.ts",
@@ -11,7 +11,8 @@
     "lint:fix": "eslint ./src ./tests --ext .ts --fix",
     "test": "jest",
     "test:coverage": "jest --coverage",
-    "ci": "npm run lint && npm run test"
+    "ci": "npm run lint && npm run test",
+    "publish:beta": "npm run build && npm publish --tag beta"
   },
   "author": "",
   "license": "MIT",
@@ -28,7 +29,7 @@
     "ts-jest": "^29.1.2",
     "typescript": "^5.3.3",
     "vite": "^5.0.12",
-    "vite-plugin-dts": "^3.7.2"
+    "vite-plugin-dts": "^4.0.0-beta.1"
   },
   "peerDependencies": {
     "axios": "^1.6.4",