<?php

namespace Illuminate\Database\Eloquent;

use Illuminate\Database\Concerns\BuildsQueries;
use Illuminate\Database\Query\Builder as QueryBuilder;
use Illuminate\Support\Traits\ForwardsCalls;

/**
 * @template-covariant TModel of \Illuminate\Database\Eloquent\Model
 * @property-read HigherOrderBuilderProxy $orWhere
 *
 * @mixin \Illuminate\Database\Query\Builder
 */
class Builder
{
    use BuildsQueries, Concerns\QueriesRelationships, ForwardsCalls;

    /**
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return void
     */
    public function __construct(QueryBuilder $query) {}

    /**
     * @param  array<string, mixed>  $attributes
     * @return TModel
     */
    public function make(array $attributes = []) {}

    /**
     * @param  string  $identifier
     * @param  \Illuminate\Database\Eloquent\Scope|\Closure  $scope
     * @return self<TModel>
     */
    public function withGlobalScope($identifier, $scope) {}

    /**
     * @param  \Illuminate\Database\Eloquent\Scope|string  $scope
     * @return self<TModel>
     */
    public function withoutGlobalScope($scope) {}

    /**
     * @return TModel
     */
    public function getModel() {}

    /**
     * @param  array<string, mixed>  $attributes
     * @return TModel
     */
    public function create(array $attributes = []) {}

    /**
     * @param  array|null  $scopes
     * @return self<TModel>
     */
    public function withoutGlobalScopes(array $scopes = null) {}

    /**
     * @return array
     */
    public function removedScopes() {}

    /**
     * @param  mixed  $id
     * @return self<TModel>
     */
    public function whereKey($id) {}

    /**
     * @param  mixed  $id
     * @return self<TModel>
     */
    public function whereKeyNot($id) {}

    /**
     * @param  string|array|\Closure  $column
     * @param  mixed   $operator
     * @param  mixed   $value
     * @param  string  $boolean
     * @return self<TModel>
     */
    public function where($column, $operator = null, $value = null, $boolean = 'and') {}

    /**
     * @param  string  $column
     * @param  string  $operator
     * @param  \DateTimeInterface|string|null  $value
     * @param  string  $boolean
     * @return self<TModel>
     */
    public function whereDate($column, $operator, $value = null, $boolean = 'and') {}

    /**
     * @param  \Closure|array|string  $column
     * @param  mixed  $operator
     * @param  mixed  $value
     * @return self<TModel>
     */
    public function orWhere($column, $operator = null, $value = null) {}

    /**
     * @param  string  $relation
     * @param  \Closure|null  $callback
     * @param  string  $operator
     * @param  int  $count
     * @return self<TModel>
     */
    public function whereHas($relation, \Closure $callback = null, $operator = '>=', $count = 1) {}

    /**
     * @param  string  $relation
     * @param  \Closure|string|array<mixed>|\Illuminate\Database\Query\Expression  $column
     * @param  mixed  $operator
     * @param  mixed  $value
     * @return self<TModel>
     */
    public function whereRelation($relation, $column, $operator = null, $value = null) {}

    /**
     * @param  positive-int  $count
     * @param  callable(\Illuminate\Database\Eloquent\Collection<int, TModel>, int): mixed $callback
     * @return bool
     */
    public function chunk($count, $callback) {}

    /**
     * @param  string  $relation
     * @param  \Closure|string|array<int, string>|\Illuminate\Database\Query\Expression  $column
     * @param  mixed  $operator
     * @param  mixed  $value
     * @return self<TModel>
     */
    public function orWhereRelation($relation, $column, $operator = null, $value = null) {}

    /**
     * @param  string  $relation
     * @param  \Closure|null  $callback
     * @param  string  $operator
     * @param  int  $count
     * @return self<TModel>
     */
    public function orWhereHas($relation, \Closure $callback = null, $operator = '>=', $count = 1) {}

    /**
     * @template TRelatedModel of Model
     * @template TChildModel of Model
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo<TRelatedModel, TChildModel>|string  $relation
     * @param  string|array<string>  $types
     * @param  string  $operator
     * @param  int  $count
     * @param  string  $boolean
     * @param  \Closure|null  $callback
     * @return self<TModel>
     */
    public function hasMorph($relation, $types, $operator = '>=', $count = 1, $boolean = 'and', \Closure $callback = null) {}

    /**
     * @template TRelatedModel of Model
     * @template TChildModel of Model
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo<TRelatedModel, TChildModel>|string  $relation
     * @param  string|array<string>  $types
     * @param  string  $operator
     * @param  int  $count
     * @return self<TModel>
     */
    public function orHasMorph($relation, $types, $operator = '>=', $count = 1) {}

    /**
     * @template TRelatedModel of Model
     * @template TChildModel of Model
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo<TRelatedModel, TChildModel>|string  $relation
     * @param  string|array<string>  $types
     * @param  string  $boolean
     * @param  \Closure|null  $callback
     * @return self<TModel>
     */
    public function doesntHaveMorph($relation, $types, $boolean = 'and', \Closure $callback = null) {}

    /**
     * @template TRelatedModel of Model
     * @template TChildModel of Model
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo<TRelatedModel, TChildModel>|string  $relation
     * @param  string|array<string>  $types
     * @return self<TModel>
     */
    public function orDoesntHaveMorph($relation, $types) {}

    /**
     * @template TRelatedModel of Model
     * @template TChildModel of Model
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo<TRelatedModel, TChildModel>|string  $relation
     * @param  string|array<string>  $types
     * @param  \Closure|null  $callback
     * @param  string  $operator
     * @param  int  $count
     * @return self<TModel>
     */
    public function whereHasMorph($relation, $types, \Closure $callback = null, $operator = '>=', $count = 1) {}

    /**
     * @template TRelatedModel of Model
     * @template TChildModel of Model
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo<TRelatedModel, TChildModel>|string  $relation
     * @param  string|array<string>  $types
     * @param  \Closure|null  $callback
     * @param  string  $operator
     * @param  int  $count
     * @return self<TModel>
     */
    public function orWhereHasMorph($relation, $types, \Closure $callback = null, $operator = '>=', $count = 1) {}

    /**
     * @template TRelatedModel of Model
     * @template TChildModel of Model
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo<TRelatedModel, TChildModel>|string  $relation
     * @param  string|array<string>  $types
     * @param  \Closure|null  $callback
     * @return self<TModel>
     */
    public function whereDoesntHaveMorph($relation, $types, \Closure $callback = null) {}

    /**
     * @template TRelatedModel of Model
     * @template TChildModel of Model
     * @param  \Illuminate\Database\Eloquent\Relations\MorphTo<TRelatedModel, TChildModel>|string  $relation
     * @param  string|array<string>  $types
     * @param  \Closure|null  $callback
     * @return self<TModel>
     */
    public function orWhereDoesntHaveMorph($relation, $types, \Closure $callback = null) {}

    /**
     * @param  \Illuminate\Database\Eloquent\Builder<TModel>  $from
     * @return self<TModel>
     */
    public function mergeConstraintsFrom(\Illuminate\Database\Eloquent\Builder $from) {}

    /**
     * @param  string  $relation
     * @param  \Closure|null  $callback
     * @return self<TModel>
     */
    public function orWhereDoesntHave($relation, \Closure $callback = null) {}

    /**
     * @param  string  $relation
     * @param  \Closure|null  $callback
     * @return self<TModel>
     */
    public function whereDoesntHave($relation, \Closure $callback = null) {}

    /**
     * @param  string  $column
     * @return self<TModel>
     */
    public function latest($column = null) {}

    /**
     * @param  string  $column
     * @return self<TModel>
     */
    public function oldest($column = null) {}

    /**
     * @param  array  $items
     * @return \Illuminate\Database\Eloquent\Collection<int, TModel>
     */
    public function hydrate(array $items) {}

    /**
     * @param  string  $query
     * @param  array  $bindings
     * @return \Illuminate\Database\Eloquent\Collection<int, TModel>
     */
    public function fromQuery($query, $bindings = []) {}

    /**
     * @template T
     * @param  T $id
     * @param  list<non-empty-string>  $columns
     * @psalm-return (T is (array|\Illuminate\Contracts\Support\Arrayable) ? \Illuminate\Database\Eloquent\Collection<int, TModel> : TModel|null)
     */
    public function find($id, $columns = ['*']) {}

    /**
     * @param  \Illuminate\Contracts\Support\Arrayable|array  $ids
     * @param  list<non-empty-string>  $columns
     * @return \Illuminate\Database\Eloquent\Collection<int, TModel>
     */
    public function findMany($ids, $columns = ['*']) {}

    /**
     * @template T
     * @param  T $id
     * @param  list<non-empty-string>  $columns
     * @psalm-return (T is (array|\Illuminate\Contracts\Support\Arrayable) ? \Illuminate\Database\Eloquent\Collection<int, TModel> : TModel)
     */
    public function findOrFail($id, $columns = ['*']) {}

    /**
     * @param  mixed  $id
     * @param  list<non-empty-string>  $columns
     * @return TModel
     */
    public function findOrNew($id, $columns = ['*']) {}

    /**
     * @return TModel|null
     */
    public function first($columns = ['*']) {}

    /**
     * @param  array<array-key, string>  $columns
     * @return TModel
     *
     * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
     */
    public function firstOrFail($columns = ['*']) {}

    /**
     * @param  \Closure|array  $columns
     * @param  \Closure|null  $callback
     * @return TModel|mixed
     */
    public function firstOr($columns = ['*'], \Closure $callback = null) {}

    /**
     * @param  array<string, mixed>  $attributes
     * @param  array  $values
     * @return TModel|self<TModel>
     */
    public function firstOrNew(array $attributes = [], array $values = []) {}

    /**
     * @param  array<string, mixed>  $attributes
     * @param  array  $values
     * @return TModel|self<TModel>
     */
    public function firstOrCreate(array $attributes = [], array $values = []) {}

    /**
     * @param  (\Closure(static): void)|(\Closure(static): static)|non-empty-string|list<non-empty-string>|int, mixed>|\Illuminate\Database\Query\Expression  $column
     * @param  string  $boolean
     * @psalm-return TModel|null
     */
    public function firstWhere($column, $operator = null, $value = null, $boolean = 'and') {}

    /**
     * @param  array<int, (model-property<TModel>|'*')>|model-property<TModel>|'*'  $columns
     * @psalm-return TModel
     */
    public function sole($columns = ['*']) {}

    /**
     * @param  array<string, mixed>  $attributes
     * @param  array  $values
     * @return TModel
     */
    public function updateOrCreate(array $attributes, array $values = []) {}

    /**
     * @param  string  $column
     * @return mixed
     */
    public function value($column) {}

    /**
     * @param  array|non-empty-string  $columns
     * @return \Illuminate\Database\Eloquent\Collection<int, TModel>
     */
    public function get($columns = ['*']) {}

    /**
     * @param  list<non-empty-string>  $columns
     * @return array<array-key, TModel>
     */
    public function getModels($columns = ['*']) {}

    /**
     * @template TRelatedModel of Model
     * @param  \Illuminate\Database\Eloquent\Relations\Relation<TRelatedModel>|string  $relation
     * @param  string  $operator
     * @param  int  $count
     * @param  string  $boolean
     * @param  \Closure|null  $callback
     * @return static
     *
     * @throws \RuntimeException
     */
    public function has($relation, $operator = '>=', $count = 1, $boolean = 'and', \Closure $callback = null) {}

    /**
     * @param  string  $relation
     * @param  string  $operator
     * @param  int  $count
     * @return static
     */
    public function orHas($relation, $operator = '>=', $count = 1) {}

    /**
     * @param  string  $relation
     * @param  string  $boolean
     * @param  \Closure|null  $callback
     * @return static
     */
    public function doesntHave($relation, $boolean = 'and', \Closure $callback = null) {}

    /**
     * @param  string  $relation
     * @return static
     */
    public function orDoesntHave($relation) {}

    /**
     * @param  array  $models
     * @return array
     */
    public function eagerLoadRelations(array $models) {}

    /**
     * @param  string  $name
     * @return \Illuminate\Database\Eloquent\Relations\Relation
     */
    public function getRelation($name) {}

    /**
     * @return \Generator
     */
    public function cursor() {}

    /**
     * @param  int  $count
     * @param  callable  $callback
     * @param  string|null  $column
     * @param  string|null  $alias
     * @return bool
     */
    public function chunkById($count, callable $callback, $column = null, $alias = null) {}

    /**
     * @return void
     */
    protected function enforceOrderBy() {}

    /**
     * @param  string  $column
     * @param  string|null  $key
     * @return \Illuminate\Support\Collection
     */
    public function pluck($column, $key = null) {}

    /**
     * @param  int  $perPage
     * @param  list<non-empty-string>  $columns
     * @param  string  $pageName
     * @param  int|null  $page
     * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator
     *
     * @throws \InvalidArgumentException
     */
    public function paginate($perPage = null, $columns = ['*'], $pageName = 'page', $page = null) {}

    /**
     * @param  int|null  $perPage
     * @param  list<non-empty-string>  $columns
     * @param  string  $pageName
     * @param  int|null  $page
     * @return \Illuminate\Contracts\Pagination\Paginator
     */
    public function simplePaginate($perPage = null, $columns = ['*'], $pageName = 'page', $page = null) {}

    /**
     * Paginate the given query into a cursor paginator.
     *
     * @param  int|null  $perPage
     * @param  array<array-key, mixed>  $columns
     * @param  string  $cursorName
     * @param  \Illuminate\Pagination\Cursor|string|null  $cursor
     * @return \Illuminate\Pagination\CursorPaginator<TModel>
     */
    public function cursorPaginate($perPage = null, $columns = ['*'], $cursorName = 'cursor', $cursor = null) {}

    /**
     * @param  int  $chunkSize
     * @return \Illuminate\Support\LazyCollection<int, TModel>
     *
     * @throws \InvalidArgumentException
     */
    public function lazy($chunkSize = 1000) {}

    /**
     * @param  int  $chunkSize
     * @param  string|null  $column
     * @param  string|null  $alias
     * @return \Illuminate\Support\LazyCollection<int, TModel>
     *
     * @throws \InvalidArgumentException
     */
    public function lazyById($chunkSize = 1000, $column = null, $alias = null) {}

    /**
     * @param  int  $chunkSize
     * @param  string|null  $column
     * @param  string|null  $alias
     * @return \Illuminate\Support\LazyCollection<int, TModel>
     *
     * @throws \InvalidArgumentException
     */
    public function lazyByIdDesc($chunkSize = 1000, $column = null, $alias = null) {}

    /**
     * @param  array<string, mixed>  $attributes
     * @return TModel
     */
    public function forceCreate(array $attributes) {}

    /**
     * @param  array  $values
     * @return int
     */
    public function update(array $values) {}

    /**
     * @param  string  $column
     * @param  float|int  $amount
     * @param  array  $extra
     * @return int
     */
    public function increment($column, $amount = 1, array $extra = []) {}

    /**
     * @param  string  $column
     * @param  float|int  $amount
     * @param  array  $extra
     * @return int
     */
    public function decrement($column, $amount = 1, array $extra = []) {}

    /**
     * @return mixed
     */
    public function delete() {}

    /**
     * @return mixed
     */
    public function forceDelete() {}

    /**
     * @param  \Closure  $callback
     * @return void
     */
    public function onDelete(Closure $callback) {}

    /**
     * Call the given local model scopes.
     *
     * @param  array|non-empty-string  $scopes
     * @return self<TModel>
     */
    public function scopes($scopes) {}

    /**
     * @return self<TModel>
     */
    public function applyScopes() {}

    /**
     * @param  mixed  $relations
     * @return self<TModel>
     */
    public function with($relations) {}

    /**
     * @param  mixed  $relations
     * @return self<TModel>
     */
    public function without($relations) {}

    /**
     * @param  array<string, mixed>  $attributes
     * @return TModel
     */
    public function newModelInstance($attributes = []) {}

    /**
     * @return \Illuminate\Database\Query\Builder
     */
    public function getQuery() {}

    /**
     * @param  \Illuminate\Database\Query\Builder  $query
     * @return self<TModel>
     */
    public function setQuery($query) {}

    /**
     * @param array $eagerLoad
     * @return self<TModel>
     */
    public function setEagerLoads(array $eagerLoad) {}

    /**
     * @param TModel $model
     * @return self<TModel>
     */
    public function setModel(Model $model) {}

    /**
     * @param  string  $columns
     * @return int
     */
    public function count($columns = '*') {}
}