@h3ravel/arquebus 0.1.4

package/dist/index.d.ts

@@ -0,0 +1,457 @@
+import Knex from 'knex';
+import { Collection as Collection$1 } from 'collect.js';
+
+declare class ModelNotFoundError extends BaseError {
+    model: any;
+    ids: any;
+    setModel(model: any, ids?: any[]): this;
+    getModel(): any;
+    getIds(): any;
+}
+declare class RelationNotFoundError extends BaseError {
+}
+declare class InvalidArgumentError extends BaseError {
+}
+declare class BaseError extends Error {
+    constructor(message: any, entity: any);
+    message: any;
+}
+
+/**
+ * Compose functional mixins
+ *
+ * @param Base
+ * @param mixins
+ * @returns
+ */
+declare function compose(Base: any, ...mixins: any[]): any;
+declare function now(format?: string): string;
+declare function getRelationName(relationMethod: any): string;
+declare function getScopeName(scopeMethod: any): string;
+declare function getRelationMethod(relation: any): string;
+declare function getScopeMethod(scope: any): string;
+declare function getAttrMethod(attr: any): string;
+declare function getGetterMethod(attr: any): string;
+declare function getSetterMethod(attr: any): string;
+declare function getAttrName(attrMethod: any): any;
+declare function tap(instance: any, callback: any): any;
+declare function flattenDeep(arr: any): any;
+declare function kebabCase(str: any): string;
+declare function snakeCase(str: any): string;
+
+declare class arquebus {
+    static connectorFactory: null;
+    static instance: null;
+    static getInstance(): null;
+    static connection(connection?: null): any;
+    static setConnectorFactory(connectorFactory: any): void;
+    static getConnectorFactory(): typeof Knex;
+    static addConnection(config: any, name?: string): any;
+    static beginTransaction(connection?: null): any;
+    static transaction(callback: any, connection?: null): any;
+    static table(name: any, connection?: null): any;
+    static schema(connection?: null): any;
+    static destroyAll(): Promise<void>;
+    static createModel(name: any, options: any): any;
+    manager: {};
+    connections: {};
+    models: {};
+    connection(connection?: null): any;
+    getConnection(name?: null): any;
+    addConnection(config: any, name?: string): void;
+    beginTransaction(connection?: null): any;
+    transaction(callback: any, connection?: null): any;
+    table(name: any, connection?: null): any;
+    schema(connection?: null): any;
+    destroyAll(): Promise<void>;
+    createModel(name: any, options?: {}): any;
+}
+
+declare class Paginator {
+    static formatter: null;
+    static setFormatter(formatter: any): void;
+    constructor(items: any, total: any, perPage: any, currentPage?: null, options?: {});
+    _items: any;
+    _total: any;
+    _perPage: number;
+    _lastPage: number;
+    _currentPage: any;
+    options: {};
+    setItems(items: any): void;
+    hasMore: boolean | undefined;
+    firstItem(): number | null;
+    lastItem(): number | null;
+    hasMorePages(): boolean;
+    get(index: any): any;
+    count(): any;
+    items(): any;
+    map(callback: any): any;
+    currentPage(): any;
+    onFirstPage(): boolean;
+    perPage(): number;
+    lastPage(): number;
+    total(): any;
+    toData(): any;
+    toJSON(): any;
+    toJson(...args: any[]): string;
+}
+
+declare class Collection extends Collection$1<any> {
+    constructor(collection?: Object | any[] | undefined);
+    load(...relations: any[]): Promise<any>;
+    loadAggregate(relations: any, column: any, action?: null): Promise<this>;
+    loadCount(relations: any): Promise<this>;
+    loadMax(relation: any, column: any): Promise<this>;
+    loadMin(relation: any, column: any): Promise<this>;
+    loadSum(relation: any, column: any): Promise<this>;
+    loadAvg(relation: any, column: any): Promise<this>;
+    mapThen(callback: any): Promise<any[]>;
+    modelKeys(): any[];
+    contains(key: any, operator?: null, value?: null, ...args: any[]): boolean;
+    diff(items: any): any;
+    except(keys: any): any;
+    intersect(items: any): any;
+    unique(key?: null, strict?: boolean): any;
+    find(key: any, defaultValue?: null): any;
+    fresh(...args: any[]): Promise<any>;
+    makeVisible(attributes: any): this;
+    makeHidden(attributes: any): this;
+    append(attributes: any): this;
+    only(keys: any): any;
+    getDictionary(items?: null): {};
+    toQuery(): any;
+    toData(): any[];
+    toJSON(): any[];
+    toJson(...args: any[]): string;
+    [Symbol.iterator](): {
+        next(): {
+            value: any;
+            done: boolean;
+        } | {
+            done: boolean;
+            value?: undefined;
+        };
+    };
+}
+
+declare class QueryBuilder {
+    constructor(config: any, connector: any);
+    connector: null;
+    asProxy(): any;
+    beginTransaction(): Promise<QueryBuilder>;
+    table(table: any): QueryBuilder;
+    transaction(callback: any): any;
+    find(id: any, columns?: string[]): Promise<any>;
+    get(columns?: string[]): Promise<null>;
+    exists(): Promise<boolean>;
+    skip(...args: any[]): any;
+    take(...args: any[]): any;
+    chunk(count: any, callback: any): Promise<boolean>;
+    paginate(page?: number, perPage?: number): Promise<Paginator>;
+    forPage(page?: number, perPage?: number): any;
+    toSQL(...args: any[]): any;
+    count(column: any): Promise<number>;
+    min(column: any): Promise<number>;
+    max(column: any): Promise<number>;
+    sum(column: any): Promise<number>;
+    avg(column: any): Promise<number>;
+    clone(): QueryBuilder;
+    delete(): Promise<any>;
+    insert(...args: any[]): Promise<any>;
+    update(...args: any[]): Promise<any>;
+    destroy(...args: any[]): any;
+    get _statements(): any;
+    get _single(): any;
+    get from(): any;
+}
+
+declare class Builder {
+    constructor(query: any);
+    query: any;
+    connection: any;
+    model: any;
+    actions: any;
+    localMacros: {};
+    eagerLoad: {};
+    globalScopes: {};
+    asProxy(): any;
+    orWhere(...args: any[]): this;
+    chunk(count: any, callback: any): Promise<boolean>;
+    enforceOrderBy(): void;
+    clone(): any;
+    forPage(page: any, perPage?: number): any;
+    insert(...args: any[]): any;
+    update(values: any): any;
+    increment(column: any, amount?: number, extra?: {}): any;
+    decrement(column: any, amount?: number, extra?: {}): any;
+    addUpdatedAtColumn(values: any): any;
+    delete(): any;
+    onDelete(callback: any): void;
+    onDeleteCallback: any;
+    forceDelete(): any;
+    create(attributes?: {}): Promise<any>;
+    newModelInstance(attributes?: {}): any;
+    getQuery(): any;
+    getModel(): any;
+    setModel(model: any): this;
+    qualifyColumn(column: any): any;
+    setTable(table: any): this;
+    applyScopes(): this;
+    hasNamedScope(name: any): any;
+    callNamedScope(scope: any, parameters: any): any;
+    callScope(scope: any, parameters?: any[]): any;
+    scopes(scopes: any): this;
+    withGlobalScope(identifier: any, scope: any): this;
+    withoutGlobalScope(scope: any): this;
+    macro(name: any, callback: any): void;
+    hasMacro(name: any): boolean;
+    getMacro(name: any): any;
+    with(...args: any[]): this;
+    has(relation: any, operator?: string, count?: number, boolean?: string, callback?: null): any;
+    orHas(relation: any, operator?: string, count?: number): any;
+    doesntHave(relation: any, boolean?: string, callback?: null): any;
+    orDoesntHave(relation: any): any;
+    whereHas(relation: any, callback?: null, operator?: string, count?: number): any;
+    orWhereHas(relation: any, callback?: null, operator?: string, count?: number): any;
+    whereRelation(relation: any, ...args: any[]): any;
+    orWhereRelation(relation: any, ...args: any[]): any;
+    hasNested(relations: any, operator?: string, count?: number, boolean?: string, callback?: null): any;
+    canUseExistsForExistenceCheck(operator: any, count: any): boolean;
+    addHasWhere(hasQuery: any, relation: any, operator: any, count: any, boolean: any): any;
+    addWhereExistsQuery(query: any, boolean?: string, not?: boolean): this;
+    addWhereCountQuery(query: any, operator?: string, count?: number, boolean?: string): any;
+    withAggregate(relations: any, column: any, action?: null): this;
+    toSql(): any;
+    mergeConstraintsFrom(from: any): any;
+    selectSub(query: any, as: any): any;
+    createSub(query: any): any[];
+    parseSub(query: any): any[];
+    prependDatabaseNameIfCrossDatabaseQuery(query: any): any;
+    getRelationWithoutConstraints(relation: any): any;
+    withCount(...args: any[]): this;
+    withMax(relation: any, column: any): this;
+    withMin(relation: any, column: any): this;
+    withAvg(relation: any, column: any): this;
+    withSum(relation: any, column: any): this;
+    withExists(relation: any): this;
+    parseWithRelations(relations: any): {};
+    addNestedWiths(name: any, results: any): any;
+    prepareNestedWithRelationships(relations: any, prefix?: string): {};
+    combineConstraints(constraints: any): (builder: any) => any;
+    parseNameAndAttributeSelectionConstraint(name: any, value: any): any[];
+    createSelectWithConstraint(name: any): any[];
+    related(relation: any): any;
+    take(...args: any[]): any;
+    skip(...args: any[]): any;
+    first(...columns: any[]): Promise<any>;
+    firstOrFail(...columns: any[]): Promise<any>;
+    findOrFail(ids: any, columns?: string): Promise<any>;
+    findOrNew(id: any, columns?: string[]): Promise<any>;
+    firstOrNew(attributes?: {}, values?: {}): Promise<any>;
+    firstOrCreate(attributes?: {}, values?: {}): Promise<any>;
+    updateOrCreate(attributes: any, values?: {}): Promise<any>;
+    latest(column?: null): this;
+    oldest(column?: null): this;
+    find(id: any, columns?: string): Promise<any>;
+    findMany(ids: any, columns?: string): Promise<any>;
+    pluck(column: any): Promise<Collection>;
+    destroy(ids: any, ...args: any[]): Promise<number>;
+    get(columns?: string): Promise<Collection>;
+    all(columns?: string): Promise<any>;
+    paginate(page: any, perPage: any): Promise<Paginator>;
+    getModels(...columns: any[]): Promise<any[]>;
+    getRelation(name: any): any;
+    relationsNestedUnder(relation: any): {};
+    isNestedUnder(relation: any, name: any): any;
+    eagerLoadRelation(models: any, name: any, constraints: any): Promise<any>;
+    eagerLoadRelations(models: any): Promise<any>;
+    hydrate(items: any): Collection;
+}
+
+declare const Model_base: any;
+declare class Model extends Model_base {
+    [x: string]: any;
+    static globalScopes: {};
+    static pluginInitializers: {};
+    static _booted: {};
+    static resolver: null;
+    static query(trx?: null): any;
+    static on(connection?: null): any;
+    static init(attributes?: {}): Model;
+    static extend(plugin: any, options: any): void;
+    static make(attributes?: {}): Model;
+    static booting(): void;
+    static boot(): void;
+    static booted(): void;
+    static setConnectionResolver(resolver: any): void;
+    constructor(attributes?: {});
+    primaryKey: string;
+    builder: null;
+    table: null;
+    connection: null;
+    keyType: string;
+    incrementing: boolean;
+    perPage: number;
+    exists: boolean;
+    eagerLoad: {};
+    with: any[];
+    withCount: any[];
+    trx: null;
+    bootIfNotBooted(): void;
+    initialize(): void;
+    initializePlugins(): void;
+    addPluginInitializer(method: any): void;
+    newInstance(attributes?: {}, exists?: boolean): any;
+    newFromBuilder(attributes?: {}, connection?: null): any;
+    asProxy(): any;
+    getKey(): any;
+    getKeyName(): string;
+    getForeignKey(): string;
+    getConnectionName(): null;
+    getTable(): string;
+    getConnection(): any;
+    setConnection(connection: any): this;
+    getKeyType(): string;
+    newQuery(trx?: null): any;
+    newQueryWithoutScopes(trx?: null): Builder;
+    newModelQuery(trx?: null): Builder;
+    addGlobalScopes(builder: any): any;
+    hasNamedScope(name: any): boolean;
+    callNamedScope(scope: any, parameters: any): any;
+    setTable(table: any): this;
+    newCollection(models?: any[]): Collection;
+    load(...relations: any[]): Promise<this>;
+    loadAggregate(relations: any, column: any, callback?: null): Promise<this>;
+    loadCount(...relations: any[]): Promise<this>;
+    loadMax(relations: any, column: any): Promise<this>;
+    loadMin(relations: any, column: any): Promise<this>;
+    loadSum(relations: any, column: any): Promise<this>;
+    increment(column: any, amount?: number, extra?: {}, options?: {}): Promise<any>;
+    decrement(column: any, amount?: number, extra?: {}, options?: {}): Promise<any>;
+    incrementOrDecrement(column: any, amount: any, extra: any, method: any, options: any): Promise<any>;
+    toData(): {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    };
+    toJSON(): {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+    };
+    toJson(...args: any[]): string;
+    toString(): string;
+    fill(attributes: any): this;
+    transacting(trx: any): this;
+    trashed(): boolean;
+    getIncrementing(): boolean;
+    setIncrementing(value: any): this;
+    save(options?: {}): Promise<boolean>;
+    update(attributes?: {}, options?: {}): Promise<boolean>;
+    delete(options?: {}): Promise<boolean>;
+    performDeleteOnModel(options?: {}): Promise<void>;
+    setKeysForSaveQuery(query: any): any;
+    forceDelete(options?: {}): Promise<boolean>;
+    fresh(): any;
+    refresh(): Promise<this | undefined>;
+    attributes: any;
+    newPivot(parent: any, attributes: any, table: any, exists: any, using?: null): any;
+    qualifyColumn(column: any): any;
+    getQualifiedKeyName(): any;
+    push(options?: {}): Promise<boolean>;
+    is(model: any): any;
+    isNot(model: any): boolean;
+}
+declare class Pivot extends Model {
+    static fromRawAttributes(parent: any, attributes: any, table: any, exists?: boolean): Pivot;
+    static fromAttributes(parent: any, attributes: any, table: any, exists?: boolean): Pivot;
+    guarded: any[];
+    pivotParent: null;
+    foreignKey: null;
+    relatedKey: null;
+    setPivotKeys(foreignKey: any, relatedKey: any): this;
+    hasTimestampAttributes(attributes?: null): boolean;
+}
+
+declare class Attribute {
+    static make(get?: null, set?: null): Attribute;
+    static get(get: any): Attribute;
+    static set(set: any): Attribute;
+    constructor({ get, set }: {
+        get?: null | undefined;
+        set?: null | undefined;
+    });
+    get: any;
+    set: any;
+    withCaching: boolean;
+    withObjectCaching: boolean;
+    withoutObjectCaching(): this;
+    shouldCache(): this;
+}
+
+declare class CastsAttributes {
+    static get(): void;
+    static set(): void;
+}
+
+declare class Migration {
+    connection: any;
+    withinTransaction: boolean;
+    getConnection(): any;
+}
+
+declare class Scope {
+    apply(builder: any, model: any): void;
+}
+
+declare function softDeletes(Model: any): {
+    new (): {
+        [x: string]: any;
+        forceDeleting: boolean;
+        initialize(): void;
+        initializeSoftDeletes(): void;
+        forceDelete(): Promise<any>;
+        forceDeleteQuietly(): any;
+        performDeleteOnModel(options?: {}): Promise<any>;
+        exists: boolean | undefined;
+        runSoftDelete(options?: {}): Promise<void>;
+        restore(options?: {}): Promise<any>;
+        restoreQuietly(): any;
+        trashed(): boolean;
+        isForceDeleting(): boolean;
+        getDeletedAtColumn(): any;
+        getQualifiedDeletedAtColumn(): any;
+    };
+    [x: string]: any;
+    bootSoftDeletes(): void;
+    softDeleted(callback: any): void;
+    restoring(callback: any): void;
+    restored(callback: any): void;
+    forceDeleting(callback: any): void;
+    forceDeleted(callback: any): void;
+};
+
+declare function HasUniqueIds(Model: any): {
+    new (): {
+        [x: string]: any;
+        useUniqueIds: boolean;
+        uniqueIds(): any[];
+        getKeyType(): any;
+        getIncrementing(): any;
+    };
+    [x: string]: any;
+};
+
+declare function migrateRun(config: any, options?: {}, destroyAll?: boolean): Promise<void>;
+declare function migrateRollback(config: any, options?: {}, destroyAll?: boolean): Promise<void>;
+declare function migrateStatus(config: any, options?: {}, destroyAll?: boolean): Promise<{
+    name: string;
+    ran: any;
+    batch: any;
+}[]>;
+
+declare function make(model: any, data: any, options?: {}): any;
+declare function makeCollection(model: any, data: any): Collection;
+declare function makePaginator(model: any, data: any): Paginator;
+
+export { Attribute, Builder, CastsAttributes, Collection, HasUniqueIds, InvalidArgumentError, Migration, Model, ModelNotFoundError, Paginator, Pivot, QueryBuilder, RelationNotFoundError, Scope, softDeletes as SoftDeletes, arquebus, compose, flattenDeep, getAttrMethod, getAttrName, getGetterMethod, getRelationMethod, getRelationName, getScopeMethod, getScopeName, getSetterMethod, kebabCase, make, makeCollection, makePaginator, migrateRollback, migrateRun, migrateStatus, now, snakeCase, tap };