@luminix/core 0.0.1-beta.1 → 0.0.1-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luminix/core",
-  "version": "0.0.1-beta.1",
+  "version": "0.0.1-beta.3",
   "description": "> Projeto em desenvolvimento",
   "main": "dist/core.js",
   "types": "dist/index.d.ts",

package/vite.config.js

@@ -1,17 +1,19 @@
 import { defineConfig } from 'vite';
 import { resolve } from 'path';
 
-import dts from 'vite-plugin-dts';
+//import dts from 'vite-plugin-dts';
+
+import packageJson from './package.json';
 
 export default defineConfig({
-    plugins: [dts({ insertTypesEntry: true })],
+    //plugins: [dts({ insertTypesEntry: true })],
     build: {
         lib: {
             entry: resolve(__dirname, 'src/index.ts'),
             formats: ['es']
         },
         rollupOptions: {
-            external: ['axios', 'lodash', 'immer']
+            external: Object.keys(packageJson.peerDependencies),
         }
     },
     

package/dist/contracts/Builder.d.ts

@@ -1,50 +0,0 @@
-import { Unsubscribe } from 'nanoevents';
-import { AppFacades } from '../types/App';
-import { BuilderEventMap as BuilderEvents, BuilderInterface as BuilderBase, ExtendedOperator } from '../types/Builder';
-import { EventData } from '../types/Event';
-import { Model, ModelPaginatedResponse, ModelQuery } from '../types/Model';
-import { JsonValue } from '../types/Support';
-import { Collection as CollectionInterface } from '../types/Collection';
-
-type BuilderInterface = BuilderBase<Model, ModelPaginatedResponse>;
-type BuilderEventMap = BuilderEvents<Model, ModelPaginatedResponse>;
-declare class Builder implements BuilderInterface {
-    protected facades: AppFacades;
-    protected abstract: string;
-    protected query: ModelQuery;
-    private bag;
-    constructor(facades: AppFacades, abstract: string, query?: ModelQuery);
-    on<T extends keyof BuilderEventMap>(_: T, __: BuilderEventMap[T]): Unsubscribe;
-    once<T extends keyof BuilderEventMap>(_: T, __: BuilderEventMap[T]): void;
-    emit<T extends keyof BuilderEventMap>(_: T, __: EventData<BuilderEventMap, T>): void;
-    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;
-    orderBy(column: string, direction?: 'asc' | 'desc'): this;
-    searchBy(term: string): this;
-    minified(): this;
-    unset(key: string): this;
-    private exec;
-    get(page?: number, replaceLinksWith?: string): Promise<ModelPaginatedResponse>;
-    first(): Promise<Model | null>;
-    find(id: string | number): Promise<Model | null>;
-    all(): Promise<CollectionInterface<Model>>;
-}
-declare const _default: {
-    new (...args: any[]): {
-        "__#1@#emitter": import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
-        "__#1@#createNanoEvents"(): import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
-        on<E extends "change" | "submit" | "success" | "error">(event: E, callback: BuilderEventMap[E]): Unsubscribe;
-        once<E_1 extends "change" | "submit" | "success" | "error">(event: E_1, callback: BuilderEventMap[E_1]): void;
-        emit<E_2 extends "change" | "submit" | "success" | "error">(event: E_2, data?: Omit<Parameters<BuilderEventMap[E_2]>[0], "source">): void;
-        [Symbol.toStringTag]: string;
-    };
-    name: string;
-} & typeof Builder;
-export default _default;

package/dist/contracts/Collection.d.ts

@@ -1,191 +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[]): {
-        "__#1@#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;
-    };
-    name: 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> {
-    static name: string;
-    intersect(values: Collection<Model> | Model[]): CollectionInterface<Model>;
-}
-export default ModelCollection;

package/dist/contracts/Plugin.d.ts

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

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/BelongsTo.d.ts

@@ -1,20 +0,0 @@
-import { default as Relation } 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 meta: RelationMetaData;
-    protected facades: AppFacades;
-    protected parent: Model;
-    protected items: Model | null;
-    constructor(meta: RelationMetaData, facades: AppFacades, parent: Model, items?: Model | null);
-    isSingle(): boolean;
-    isMultiple(): boolean;
-    query(): BuilderInterface;
-    get(): Promise<Model | null>;
-    associate(item: Model): Promise<void>;
-    dissociate(): Promise<void>;
-}
-export {};

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

@@ -1,31 +0,0 @@
-import { default as Relation } 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 meta: RelationMetaData;
-    protected facades: AppFacades;
-    protected parent: Model;
-    protected items: CollectionInterface<Model> | null;
-    constructor(meta: RelationMetaData, facades: AppFacades, parent: Model, items?: CollectionInterface<Model> | null);
-    isSingle(): boolean;
-    isMultiple(): boolean;
-    query(): BuilderInterface;
-    get(page?: number, replaceLinksWith?: string): Promise<ModelPaginatedResponse>;
-    all(): Promise<CollectionInterface<Model>>;
-    first(): Promise<Model | null>;
-    find(id: string | number): Promise<Model | null>;
-    attachQuietly(id: string | number, pivot?: JsonObject): Promise<import('axios').AxiosResponse<any, any>>;
-    attach(id: string | number, pivot?: JsonObject): Promise<void>;
-    detachQuietly(id: string | number): Promise<void>;
-    detach(id: string | number): Promise<void>;
-    syncQuietly(ids: (string | number | JsonObject)[]): Promise<void>;
-    syncWithPivotValuesQuietly(ids: (string | number)[], pivot: JsonObject): Promise<void>;
-    sync(ids: (string | number | JsonObject)[]): Promise<void>;
-    syncWithPivotValues(ids: (string | number)[], pivot: JsonObject): Promise<void>;
-}
-export {};

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

@@ -1,21 +0,0 @@
-import { AppFacades } from '../../types/App';
-import { Model, RelationMetaData } from '../../types/Model';
-import { default as HasOneOrMany } from './HasOneOrMany';
-import { Collection as CollectionInterface } from '../../types/Collection';
-
-export default class HasMany extends HasOneOrMany {
-    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);
-    isSingle(): boolean;
-    isMultiple(): boolean;
-    get(page?: number, replaceLinksWith?: string): Promise<import('../../types/Model').ModelPaginatedResponse>;
-    all(): Promise<CollectionInterface<Model>>;
-    first(): Promise<Model | null>;
-    find(id: string | number): Promise<Model | null>;
-    saveManyQuietly(models: Model[]): Promise<void>;
-    saveMany(models: Model[]): Promise<void>;
-    save(item: Model): Promise<void>;
-}

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

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

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

@@ -1,10 +0,0 @@
-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;
-    saveQuietly(item: Model): Promise<void>;
-}
-export {};

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

@@ -1,21 +0,0 @@
-import { AppFacades } from '../../types/App';
-import { Model, RelationMetaData } from '../../types/Model';
-import { default as MorphOneOrMany } from './MorphOneOrMany';
-import { Collection as CollectionInterface } from '../../types/Collection';
-
-export default class MorphMany extends MorphOneOrMany {
-    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);
-    isSingle(): boolean;
-    isMultiple(): boolean;
-    get(page?: number, replaceLinksWith?: string): Promise<import('../../types/Model').ModelPaginatedResponse>;
-    all(): Promise<CollectionInterface<Model>>;
-    first(): Promise<Model | null>;
-    find(id: string | number): Promise<Model | null>;
-    saveManyQuietly(models: Model[]): Promise<void>;
-    save(item: Model): Promise<void>;
-    saveMany(models: Model[]): Promise<void>;
-}

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

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

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

@@ -1,10 +0,0 @@
-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;
-    saveQuietly(item: Model): Promise<void>;
-}
-export {};

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

@@ -1,8 +0,0 @@
-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>;
-    dissociate(): Promise<void>;
-}

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/contracts/Relation.d.ts

@@ -1,44 +0,0 @@
-import { AppFacades } from '../types/App';
-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';
-
-type RelationInterface = RelationBase<Model, ModelPaginatedResponse>;
-type BuilderInterface = Builder<Model, ModelPaginatedResponse>;
-type Scope = ScopeBase<Model, ModelPaginatedResponse>;
-export default class Relation implements RelationInterface {
-    protected meta: RelationMetaData;
-    protected facades: AppFacades;
-    protected parent: BaseModel;
-    protected items: Model | CollectionInterface<Model> | null;
-    private unsubscribeQuery;
-    constructor(meta: RelationMetaData, facades: AppFacades, parent: BaseModel, items?: Model | CollectionInterface<Model> | null);
-    make(data: JsonValue): void;
-    guessInverseRelation(): string;
-    set(items: Model | CollectionInterface<Model> | null): void;
-    getForeignKey(): string | null;
-    getName(): string;
-    getType(): "HasOne" | "HasMany" | "BelongsTo" | "BelongsToMany" | "MorphOne" | "MorphMany" | "MorphTo" | "MorphToMany" | "MorphedByMany";
-    getModel(): string;
-    getRelated(): typeof Model;
-    query(): Builder<Model, ModelPaginatedResponse>;
-    isLoaded(): boolean;
-    getLoadedItems(): Model | CollectionInterface<Model> | null;
-    isSingle(): boolean;
-    isMultiple(): boolean;
-    getParent(): BaseModel;
-    where(scope: Scope): BuilderInterface;
-    where(key: string, value: JsonValue): BuilderInterface;
-    where(key: string, operator: ExtendedOperator, value: JsonValue): BuilderInterface;
-    whereNull(key: string): Builder<Model, ModelPaginatedResponse>;
-    whereNotNull(key: string): Builder<Model, ModelPaginatedResponse>;
-    whereBetween(key: string, value: [JsonValue, JsonValue]): Builder<Model, ModelPaginatedResponse>;
-    whereNotBetween(key: string, value: [JsonValue, JsonValue]): Builder<Model, ModelPaginatedResponse>;
-    orderBy(column: string, direction?: 'asc' | 'desc'): Builder<Model, ModelPaginatedResponse>;
-    searchBy(term: string): Builder<Model, ModelPaginatedResponse>;
-    minified(): Builder<Model, ModelPaginatedResponse>;
-    limit(value: number): Builder<Model, ModelPaginatedResponse>;
-}
-export {};

package/dist/exceptions/AttributeNotFillableException.d.ts

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

package/dist/exceptions/FacadeNotFoundException.d.ts

@@ -1,4 +0,0 @@
-export default class FacadeNotFoundException extends Error {
-    static name: string;
-    constructor(name: string);
-}

package/dist/exceptions/MethodNotImplementedException.d.ts

@@ -1,4 +0,0 @@
-export default class MethodNotImplementedException extends Error {
-    static name: string;
-    constructor();
-}

package/dist/exceptions/ModelInvalidRelatedTypeException.d.ts

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

package/dist/exceptions/ModelNotFoundException.d.ts

@@ -1,4 +0,0 @@
-export default class ModelNotFoundException extends Error {
-    static name: string;
-    constructor(model: string);
-}

package/dist/exceptions/ModelNotPersistedException.d.ts

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

package/dist/exceptions/ModelWithoutPrimaryKeyException.d.ts

@@ -1,4 +0,0 @@
-export default class ModelWithoutPrimaryKeyException extends Error {
-    static name: string;
-    constructor(model: string);
-}

package/dist/exceptions/NoEmbedException.d.ts

@@ -1,4 +0,0 @@
-export default class NoEmbedException extends Error {
-    static name: string;
-    constructor();
-}

package/dist/exceptions/NoInverseRelationException.d.ts

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

package/dist/exceptions/NotModelException.d.ts

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

package/dist/exceptions/NotReducibleException.d.ts

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

package/dist/exceptions/ReducerOverrideException.d.ts

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

package/dist/exceptions/RouteNotFoundException.d.ts

@@ -1,4 +0,0 @@
-export default class RouteNotFoundException extends Error {
-    static name: string;
-    constructor(route: string);
-}

package/dist/exceptions/UnsupportedRelationException.d.ts

@@ -1,4 +0,0 @@
-export default class UnsupportedRelationException extends Error {
-    static name: string;
-    constructor(relation: string);
-}