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

package/dist/contracts/Collection.d.ts

@@ -1,190 +0,0 @@
-import { CollectionEvents, Operator, Collection as CollectionInterface, CollectionIteratorCallback, CollectionPipeCallback, CollectionSortCallback } from '../types/Collection';
-import { JsonValue, Constructor, TypeOf } from '../types/Support';
-import { Unsubscribe } from 'nanoevents';
-
-export declare function collect<T = unknown, C extends typeof Collection<T> = typeof Collection<T>>(items?: T[], constructor?: C): CollectionInterface<T>;
-export declare class Collection<T> implements CollectionInterface<T> {
-    #private;
-    constructor(items?: Array<T>);
-    get items(): T[];
-    [Symbol.iterator](): IterableIterator<T>;
-    [Symbol.toStringTag]: string;
-    all(): T[];
-    average(): number;
-    average<K extends keyof T>(key: K): number;
-    avg(): number;
-    avg<K extends keyof T>(key: K): number;
-    chunk(size: number): CollectionInterface<CollectionInterface<T>>;
-    chunkWhile(callback: CollectionIteratorCallback<T, boolean>): CollectionInterface<CollectionInterface<T>>;
-    collapse(): CollectionInterface<unknown>;
-    collect(): CollectionInterface<T>;
-    combine(values: CollectionInterface<JsonValue> | JsonValue[]): Record<string, JsonValue>;
-    concat(collection: CollectionInterface<unknown> | unknown[]): CollectionInterface<unknown>;
-    contains(value: T): boolean;
-    contains(key: keyof T, value: T): boolean;
-    contains(callback: CollectionIteratorCallback<T, boolean>): boolean;
-    containsOneItem(): boolean;
-    containsStrict(value: T): boolean;
-    containsStrict(key: keyof T, value: T): boolean;
-    containsStrict(callback: CollectionIteratorCallback<T, boolean>): boolean;
-    count(): number;
-    countBy(callback?: CollectionIteratorCallback<T, string | number>): Record<string | number, number>;
-    crossJoin<V>(...collections: (CollectionInterface<V> | V[])[]): CollectionInterface<Array<V | T>>;
-    diff(collection: CollectionInterface<T> | T[]): CollectionInterface<T>;
-    doesntContain(value: T): boolean;
-    doesntContain(key: keyof T, value: T): boolean;
-    doesntContain(callback: CollectionIteratorCallback<T, boolean>): boolean;
-    dump(): void;
-    duplicates(): CollectionInterface<T>;
-    duplicates<K extends keyof T>(key: K): CollectionInterface<T[K]>;
-    duplicatesStrict(): CollectionInterface<T>;
-    duplicatesStrict<K extends keyof T>(key: K): CollectionInterface<T[K]>;
-    each(callback: CollectionIteratorCallback<T, void | false>): this;
-    eachSpread(callback: (...args: unknown[]) => void | false): this;
-    ensure(type: TypeOf | Constructor | (TypeOf | Constructor)[]): this;
-    every(callback: CollectionIteratorCallback<T, boolean>): boolean;
-    except(indexes: Array<number>): CollectionInterface<T>;
-    filter(callback?: CollectionIteratorCallback<T, boolean>): CollectionInterface<T>;
-    first(callback?: CollectionIteratorCallback<T, boolean>): T | null;
-    firstOrFail(callback?: CollectionIteratorCallback<T, boolean>): T;
-    firstWhere(key: keyof T): T | null;
-    firstWhere(key: keyof T, value: T): T | null;
-    firstWhere(key: keyof T, operator: Operator, value: T): T | null;
-    flatMap<R>(callback: CollectionIteratorCallback<T, R | R[]>): CollectionInterface<R>;
-    forget(key: number): this;
-    forPage(page: number, perPage: number): CollectionInterface<T>;
-    get(key: number): T | null;
-    get<R>(key: number, defaultValue: R): T | R;
-    get<R>(key: number, defaultValue: () => R): T | R;
-    groupBy(key: keyof T): Record<string, T[]>;
-    groupBy(callback: CollectionIteratorCallback<T, string | string[]>): Record<string, T[]>;
-    groupBy(keys: (keyof T | CollectionIteratorCallback<T, string | string[]>)[]): Record<string, unknown>;
-    has(index: number): boolean;
-    hasAny(indexes: number[]): boolean;
-    implode(glue: string): string;
-    implode(key: keyof T, glue: string): string;
-    implode(callback: CollectionIteratorCallback<T, string>, glue: string): string;
-    intersect(values: Collection<T> | T[]): CollectionInterface<T>;
-    isEmpty(): boolean;
-    isNotEmpty(): boolean;
-    join(glue: string): string;
-    join(glue: string, final: string): string;
-    keyBy(key: keyof T): Record<string, T>;
-    keyBy(callback: CollectionIteratorCallback<T, string>): Record<string, T>;
-    last(callback?: CollectionIteratorCallback<T, boolean> | undefined): T | null;
-    map<R>(callback: CollectionIteratorCallback<T, R>): CollectionInterface<R>;
-    mapInto<R extends Constructor<InstanceType<R>>>(constructor: R): CollectionInterface<InstanceType<R>>;
-    mapSpread<R>(callback: (...args: unknown[]) => R): CollectionInterface<R>;
-    mapToGroups<R>(callback: CollectionIteratorCallback<T, Record<string, R>>): Record<string, R[]>;
-    mapWithKeys<R>(callback: CollectionIteratorCallback<T, Record<string, R>>): Record<string, R>;
-    max(): T | null;
-    max<K extends keyof T>(key: K): T[K] | null;
-    median(): T | null;
-    median<K extends keyof T>(key: K): T[K] | null;
-    merge(values: CollectionInterface<T> | T[]): CollectionInterface<T>;
-    merge<R>(values: CollectionInterface<R> | R[]): CollectionInterface<T | R>;
-    min(): T | null;
-    min<K extends keyof T>(key: K): T[K] | null;
-    mode(): T[];
-    mode<K extends keyof T>(key: K): T[K][];
-    nth(n: number, offset?: number): CollectionInterface<T>;
-    only(indexes: Array<number>): CollectionInterface<T>;
-    pad<R>(size: number, value?: R | null): CollectionInterface<T | R | null>;
-    partition(callback: CollectionIteratorCallback<T, boolean>): [CollectionInterface<T>, CollectionInterface<T>];
-    percentage(callback: CollectionIteratorCallback<T, boolean>, precision?: number): number;
-    pipe<R>(callback: CollectionPipeCallback<T, R>): R;
-    pipeInto<R extends Constructor<InstanceType<R>>>(constructor: R): InstanceType<R>;
-    pipeThrough<R>(pipeline: CollectionPipeCallback<unknown, CollectionInterface<unknown> | R>[]): R;
-    pluck<K extends keyof T>(key: K): CollectionInterface<T[K]>;
-    pop(): T | null;
-    pop(amount: number): CollectionInterface<T>;
-    prepend(value: T): number;
-    pull(index: number): T | null;
-    push(...items: T[]): number;
-    put(index: number, value: T): this;
-    random(): T | null;
-    random(amount: number): CollectionInterface<T>;
-    reduce<R>(callback: (carry: R | null, item: T, index: number, collection: this) => R, initialValue?: R | null): R | null;
-    reject(callback: CollectionIteratorCallback<T, boolean>): CollectionInterface<T>;
-    replace(data: Record<number, T>): CollectionInterface<T>;
-    reverse(): CollectionInterface<T>;
-    search(value: T): number | false;
-    search(value: T, strict: boolean): number | false;
-    search(callback: CollectionIteratorCallback<T, boolean>): number | false;
-    select<K extends Array<keyof T>>(keys: K): CollectionInterface<Pick<T, K[number]>>;
-    shift(): T | null;
-    shift(count: number): CollectionInterface<T>;
-    shuffle(): CollectionInterface<T>;
-    skip(amount: number): CollectionInterface<T>;
-    skipUntil(callback: CollectionIteratorCallback<T, boolean>): CollectionInterface<T>;
-    skipUntil(value: T): CollectionInterface<T>;
-    skipWhile(callback: CollectionIteratorCallback<T, boolean>): CollectionInterface<T>;
-    skipWhile(value: T): CollectionInterface<T>;
-    slice(start?: number, size?: number): CollectionInterface<T>;
-    sliding(size: number, step?: number): CollectionInterface<CollectionInterface<T>>;
-    sole(): T | null;
-    sole<K extends keyof T>(key: K, value: T[K]): T | null;
-    sole(callback: CollectionIteratorCallback<T, boolean>): T | null;
-    some(value: T): boolean;
-    some(key: keyof T, value: T): boolean;
-    some(callback: CollectionIteratorCallback<T, boolean>): boolean;
-    sort(compareFn?: CollectionSortCallback<T>): CollectionInterface<T>;
-    sortBy<K extends keyof T>(key: K, order?: 'asc' | 'desc'): CollectionInterface<T>;
-    sortBy<K extends keyof T>(columns: [K, 'asc' | 'desc'][]): CollectionInterface<T>;
-    sortBy(callback: CollectionIteratorCallback<T, number>): CollectionInterface<T>;
-    sortBy(stack: ((a: T, b: T) => number)[]): CollectionInterface<T>;
-    sortDesc(): CollectionInterface<T>;
-    splice(start: number): CollectionInterface<T>;
-    splice(start: number, deleteCount: number): CollectionInterface<T>;
-    splice(start: number, deleteCount: number, ...items: T[]): CollectionInterface<T>;
-    split(groups: number): CollectionInterface<CollectionInterface<T>>;
-    splitIn(groups: number): CollectionInterface<CollectionInterface<T>>;
-    sum(): number;
-    sum<K extends keyof T>(key: K): number;
-    take(amount: number): CollectionInterface<T>;
-    takeUntil(value: T): CollectionInterface<T>;
-    takeUntil(callback: CollectionIteratorCallback<T, boolean>): CollectionInterface<T>;
-    takeWhile(value: T): CollectionInterface<T>;
-    takeWhile(callback: CollectionIteratorCallback<T, boolean>): CollectionInterface<T>;
-    tap(callback: CollectionPipeCallback<T, void>): this;
-    toArray(): T[];
-    toJson(): string;
-    transform<R>(callback: CollectionIteratorCallback<T, R>): CollectionInterface<T | R>;
-    unique(): CollectionInterface<T>;
-    unique<K extends keyof T>(key: K): CollectionInterface<T>;
-    uniqueStrict(): CollectionInterface<T>;
-    uniqueStrict<K extends keyof T>(key: K): CollectionInterface<T>;
-    unless(condition: boolean, callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
-    unlessEmpty(callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
-    unlessNotEmpty(callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
-    value<K extends keyof T>(key: K): T[K] | null;
-    when(condition: boolean, callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
-    whenEmpty(callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
-    whenNotEmpty(callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
-    where<K extends keyof T>(key: K, value: T[K]): CollectionInterface<T>;
-    where<K extends keyof T>(key: K, operator: Operator, value: T[K]): CollectionInterface<T>;
-    whereStrict<K extends keyof T>(key: K, value: T[K]): CollectionInterface<T>;
-    whereStrict<K extends keyof T>(key: K, operator: Operator, value: T[K]): CollectionInterface<T>;
-    whereBetween<K extends keyof T>(key: K, [min, max]: [T[K], T[K]]): CollectionInterface<T>;
-    whereIn<K extends keyof T>(key: K, values: T[K][]): CollectionInterface<T>;
-    whereInstanceOf<R extends Constructor<T>>(constructor: R): CollectionInterface<T>;
-    whereNotBetween<K extends keyof T>(key: K, [min, max]: [T[K], T[K]]): CollectionInterface<T>;
-    whereNotIn<K extends keyof T>(key: K, values: T[K][]): CollectionInterface<T>;
-    whereNotNull<K extends keyof T>(key: K): CollectionInterface<T>;
-    whereNull<K extends keyof T>(key: K): CollectionInterface<T>;
-    zip<R>(items: CollectionInterface<R> | R[]): CollectionInterface<[T, R | null]>;
-    on<K extends keyof CollectionEvents<T>>(_: K, __: CollectionEvents<T>[K]): Unsubscribe;
-    once<K extends keyof CollectionEvents<T>>(_: K, __: CollectionEvents<T>[K]): void;
-    emit<K extends keyof CollectionEvents<T>>(_: K, __?: Omit<Parameters<CollectionEvents<T>[K]>[0], 'source'>): void;
-}
-declare const _default: {
-    new (...args: any[]): {
-        emitter: import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
-        "__#1@#createNanoEvents"(): import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
-        on<E extends "change">(event: E, callback: CollectionEvents<unknown>[E]): Unsubscribe;
-        once<E_1 extends "change">(event: E_1, callback: CollectionEvents<unknown>[E_1]): void;
-        emit<E_2 extends "change">(event: E_2, data?: Omit<Parameters<CollectionEvents<unknown>[E_2]>[0], "source">): void;
-        [Symbol.toStringTag]: string;
-    };
-} & typeof Collection;
-export default _default;

package/dist/contracts/ModelCollection.d.ts

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

package/dist/contracts/PropertyBag.d.ts

@@ -1,21 +0,0 @@
-import { PropertyBag as PropertyBagInterface, PropertyBagEventMap } from '../types/PropertyBag';
-import { Unsubscribe } from 'nanoevents';
-
-declare class PropertyBag<T extends object> implements PropertyBagInterface<T> {
-    private bag;
-    private locked;
-    constructor(bag: T);
-    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(): PropertyBagInterface<T>;
-    all(): T;
-    isEmpty(): boolean;
-    on<K extends keyof PropertyBagEventMap<T>>(_: K, __: PropertyBagEventMap[K]): Unsubscribe;
-    once<K extends keyof PropertyBagEventMap<T>>(_: K, __: PropertyBagEventMap[K]): void;
-    emit<K extends keyof PropertyBagEventMap<T>>(_: K, __: Omit<Parameters<PropertyBagEventMap[K]>[0], 'source'>): void;
-}
-export default PropertyBag;

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

@@ -1,16 +0,0 @@
-import { AppFacades } from '../../types/App';
-import { BuilderInterface as Builder } from '../../types/Builder';
-import { Model, ModelPaginatedResponse, RelationMetaData } from '../../types/Model';
-import { Collection } from '../../types/Collection';
-import { default as BelongsToMany } from './BelongsToMany';
-
-type BuilderInterface = Builder<Model, ModelPaginatedResponse>;
-export default class MorphToMany extends BelongsToMany {
-    protected meta: RelationMetaData;
-    protected facades: AppFacades;
-    protected parent: Model;
-    protected items: Collection<Model> | null;
-    constructor(meta: RelationMetaData, facades: AppFacades, parent: Model, items?: Collection<Model> | null);
-    query(): BuilderInterface;
-}
-export {};

package/dist/facades/App.d.ts

@@ -1,37 +0,0 @@
-import { AppFacades, AppFacade, AppEvents } from '../types/App';
-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;
-    private _plugins;
-    make(): AppFacades;
-    make<K extends keyof AppFacades>(key: K): AppFacades[K];
-    has(key: string): boolean;
-    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[]): {
-        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;
-    };
-} & typeof App;
-export default _default;

package/dist/facades/Auth.d.ts

@@ -1,14 +0,0 @@
-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;
-    constructor(app: AppFacade);
-    attempt(credentials: AuthCredentials, remember?: boolean, onSubmit?: (e: Event) => void): void;
-    check(): boolean;
-    logout(onSubmit?: (e: Event) => void): void;
-    user(): Model | null;
-    id(): number | string | null;
-}

package/dist/facades/Model.d.ts

@@ -1,41 +0,0 @@
-import { ModelSchema, ModelSchemaAttributes, Model } from '../types/Model';
-import { AppFacade, GlobalModelEvents, ModelFacade as ModelFacadeInterface } from '../types/App';
-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;
-    [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;
-    toString(): string;
-    on<K extends keyof GlobalModelEvents>(_: K, __: GlobalModelEvents[K]): Unsubscribe;
-    once<K extends keyof GlobalModelEvents>(_: K, __: GlobalModelEvents[K]): void;
-    emit<K extends keyof GlobalModelEvents>(_: K, __?: Omit<Parameters<GlobalModelEvents[K]>[0], 'source'>): void;
-    reducer(_: string, __: ReducerCallback, ___?: number): UnsubscribeReducer;
-    removeReducer(_: string): void;
-    getReducer(_: string): Collection<Reducer>;
-    hasReducer(_: string): boolean;
-    clearReducer(_: string): void;
-    flushReducers(): void;
-    [reducer: string]: unknown;
-}
-declare const _default: {
-    new (...args: any[]): {
-        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;
-    };
-} & typeof ModelFacade;
-export default _default;

package/dist/facades/Route.d.ts

@@ -1,32 +0,0 @@
-import { RouteDefinition, RouteTuple as RouteTuple, HttpMethod, RouteGenerator, RouteCallConfig } from '../types/Route';
-import { ErrorFacade } from '../types/Error';
-
-declare class Route {
-    private routes;
-    private error;
-    private appUrl;
-    constructor(routes: RouteDefinition, error: ErrorFacade, appUrl?: string);
-    private isRouteTuple;
-    private extractGenerator;
-    get(name: string): RouteTuple;
-    url(generator: RouteGenerator): string;
-    methods(generator: RouteGenerator): HttpMethod[];
-    exists(name: string): boolean;
-    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>;
-        };
-        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;
-    };
-} & typeof Route;
-export default _default;

package/dist/helpers/app.d.ts

@@ -1,5 +0,0 @@
-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/collect.d.ts

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

package/dist/helpers/log.d.ts

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

package/dist/mixins/BaseModel.d.ts

@@ -1,5 +0,0 @@
-import { BaseModel, Model as ModelInterface } from '../types/Model';
-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 +0,0 @@
-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[]): {
-        emitter: Emitter<EventSourceEvents>;
-        "__#1@#createNanoEvents"(): Emitter<EventSourceEvents>;
-        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;
-    };
-} & U;

package/dist/mixins/Reducible.d.ts

@@ -1,17 +0,0 @@
-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: {
-            [name: string]: Collection<Reducer>;
-        };
-        reducer(name: string, callback: ReducerCallback, priority?: number): () => void;
-        removeReducer(name: string, callback: ReducerCallback): void;
-        getReducer(name: string): Collection<Reducer>;
-        hasReducer(name: string): boolean;
-        clearReducer(name: string): void;
-        flushReducers(): void;
-    };
-} & T;

package/dist/support/collection.d.ts

@@ -1,4 +0,0 @@
-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/reader.d.ts

@@ -1,2 +0,0 @@
-declare const reader: (name: string, type?: 'data' | 'error') => any;
-export default reader;

package/dist/support/searchParams.d.ts

@@ -1 +0,0 @@
-export declare const createMergedSearchParams: (...urls: string[]) => URLSearchParams;

package/dist/types/App.d.ts

@@ -1,79 +0,0 @@
-import { AppConfiguration, ConfigFacade } from './Config';
-import { PluginInterface } from './Plugin';
-import { LogFacade } from './Log';
-import { AuthFacade } from './Auth';
-import { BaseModel, Model, ModelSchema, ModelSchemaAttributes } from './Model';
-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;
-    'delete': (e: ModelGlobalEvent) => void;
-    'restore': (e: ModelGlobalEvent) => void;
-    'create': (e: ModelGlobalEvent) => void;
-    'update': (e: ModelGlobalEvent) => void;
-    'fetch': (e: ModelGlobalEvent) => void;
-    'error': (e: ModelGlobalErrorEvent) => void;
-};
-export type ModelGlobalEvent = Event<ModelFacade> & {
-    class: string;
-    model: BaseModel;
-    force?: boolean;
-};
-export type ModelGlobalErrorEvent = ModelGlobalEvent & {
-    error: unknown;
-    operation: 'save' | 'delete' | 'restore' | 'forceDelete';
-};
-export type ModelFacade = EventSource<GlobalModelEvents> & ReducibleInterface & {
-    schema(): ModelSchema;
-    schema(abstract: string): ModelSchemaAttributes;
-    make(): Record<string, typeof Model>;
-    make(abstract: string): typeof Model;
-    boot(app: AppFacade): void;
-};
-export type AppEvents = {
-    'init': (e: InitEvent) => void;
-    'booted': (e: Event<AppFacade>) => void;
-    'booting': (e: Event<AppFacade>) => void;
-};
-export type InitEvent = Event<AppFacade> & {
-    register(plugin: Plugin): void;
-};
-export type AppExternal = {
-    boot: (config?: AppConfiguration) => Promise<AppFacades>;
-    make(): AppFacades;
-    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;
-    bind<T extends keyof AppFacades>(key: T, facade: AppFacades[T]): void;
-    emit: EventSource<AppEvents>['emit'];
-    once: EventSource<AppEvents>['once'];
-    on: EventSource<AppEvents>['on'];
-};
-export type AppFacades = {
-    auth: AuthFacade;
-    config: ConfigFacade;
-    error: ErrorFacade;
-    log: LogFacade;
-    model: ModelFacade;
-    route: RouteFacade;
-    [key: string]: any;
-};
-export type BootOptions = {
-    config?: AppConfiguration;
-    skipBootRequest?: boolean;
-};
-export {};

package/dist/types/Builder.d.ts

@@ -1,51 +0,0 @@
-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>> & {
-    lock(path: string): void;
-    where(scope: Scope<R, C>): BuilderInterface<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>;
-    whereNotBetween(key: string, value: [JsonValue, JsonValue]): BuilderInterface<R, C>;
-    orderBy(column: string, direction?: 'asc' | 'desc'): BuilderInterface<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>;
-    find(id: string | number): Promise<R | null>;
-    unset(key: string): BuilderInterface<R, C>;
-};
-export type BuilderEventMap<R, C> = PropertyBagEventMap & {
-    'change': (e: BuilderChangeEvent<R, C>) => void;
-    'submit': (e: BuilderSubmitEvent<R, C>) => void;
-    'success': (e: BuilderSuccessEvent<R, C>) => void;
-    'error': (e: BuilderErrorEvent<R, C>) => void;
-};
-export type BuilderChangeEvent<R, C> = Event<BuilderInterface<R, C>> & {
-    data: PropertyBag<JsonObject>;
-};
-export type BuilderSubmitEvent<R, C> = Event<BuilderInterface<R, C>> & {
-    data: PropertyBag<JsonObject>;
-};
-export type BuilderSuccessEvent<R, C> = Event<BuilderInterface<R, C>> & {
-    response: C;
-    items: Collection<R> | R | null;
-};
-export type BuilderErrorEvent<R, C> = Event<BuilderInterface<R, C>> & {
-    error: unknown;
-};