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

package/dist/contracts/Builder.d.ts

@@ -0,0 +1,49 @@
+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;
+    };
+} & typeof Builder;
+export default _default;

package/dist/contracts/Collection.d.ts

@@ -0,0 +1,190 @@
+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;
+    };
+} & typeof Collection;
+export default _default;

package/dist/contracts/ModelCollection.d.ts

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,44 @@
+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 {};