diff --git a/.github/workflows/publish-docker-images.yml b/.github/workflows/publish-docker-images.yml index fbcfa70..b0075be 100644 --- a/.github/workflows/publish-docker-images.yml +++ b/.github/workflows/publish-docker-images.yml @@ -9,7 +9,6 @@ on: branches: - master - develop - - feature/refactor tags: [ 'v*.*.*' ] workflow_dispatch: @@ -33,11 +32,11 @@ jobs: uses: actions/checkout@v3 - name: Set up Docker Buildx - uses: docker/setup-buildx-action@f95db51fddba0c2d1ec667646a06c2ce06100226 # v3.0.0 + uses: docker/setup-buildx-action@v3 - name: Log into registry ${{ env.REGISTRY }} if: github.event_name != 'pull_request' - uses: docker/login-action@343f7c4344506bcbf9b4de18042ae17996df046d # v3.0.0 + uses: docker/login-action@v3 with: registry: ${{ env.REGISTRY }} username: ${{ github.actor }} @@ -45,18 +44,17 @@ jobs: - name: Extract Docker metadata id: meta - uses: docker/metadata-action@96383f45573cb7f253c731d3b3ab81c87ef81934 # v5.0.0 + uses: docker/metadata-action@v5 with: images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }} tags: | type=raw,value=latest,enable=${{ github.ref == format('refs/heads/{0}', 'master') }} type=raw,value=develop,enable=${{ github.ref == format('refs/heads/{0}', 'develop') }} type=semver,pattern={{version}} - type=raw,value=feature-refactor,enable=${{ github.ref == format('refs/heads/{0}', 'feature/refactor') }} - name: Build and push Docker image id: build-and-push - uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # v5.0.0 + uses: docker/build-push-action@v6 with: file: docker/production/Dockerfile context: . @@ -65,3 +63,4 @@ jobs: labels: ${{ steps.meta.outputs.labels }} cache-from: type=gha cache-to: type=gha,mode=max + platforms: linux/amd64,linux/arm64 diff --git a/_ide_helper.php b/_ide_helper.php new file mode 100644 index 0000000..68dc9e4 --- /dev/null +++ b/_ide_helper.php @@ -0,0 +1,4779 @@ + + * @see https://github.com/barryvdh/laravel-ide-helper + */ + +namespace { + + /** + * + * + * @template TCollection of static + * @template TModel of static + * @template TValue of static + * @template TValue of static + */ + class Eloquent extends \Illuminate\Database\Eloquent\Model { /** + * Create and return an un-saved model instance. + * + * @param array $attributes + * @return TModel + * @static + */ + public static function make($attributes = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->make($attributes); + } + + /** + * Register a new global scope. + * + * @param string $identifier + * @param \Illuminate\Database\Eloquent\Scope|\Closure $scope + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withGlobalScope($identifier, $scope) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withGlobalScope($identifier, $scope); + } + + /** + * Remove a registered global scope. + * + * @param \Illuminate\Database\Eloquent\Scope|string $scope + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withoutGlobalScope($scope) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withoutGlobalScope($scope); + } + + /** + * Remove all or passed registered global scopes. + * + * @param array|null $scopes + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withoutGlobalScopes($scopes = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withoutGlobalScopes($scopes); + } + + /** + * Get an array of global scopes that were removed from the query. + * + * @return array + * @static + */ + public static function removedScopes() + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->removedScopes(); + } + + /** + * Add a where clause on the primary key to the query. + * + * @param mixed $id + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereKey($id) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereKey($id); + } + + /** + * Add a where clause on the primary key to the query. + * + * @param mixed $id + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereKeyNot($id) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereKeyNot($id); + } + + /** + * Add a basic where clause to the query. + * + * @param (\Closure(static): mixed)|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function where($column, $operator = null, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->where($column, $operator, $value, $boolean); + } + + /** + * Add a basic where clause to the query, and return the first result. + * + * @param (\Closure(static): mixed)|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @param string $boolean + * @return TModel|null + * @static + */ + public static function firstWhere($column, $operator = null, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->firstWhere($column, $operator, $value, $boolean); + } + + /** + * Add an "or where" clause to the query. + * + * @param (\Closure(static): mixed)|array|string|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhere($column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhere($column, $operator, $value); + } + + /** + * Add a basic "where not" clause to the query. + * + * @param (\Closure(static): mixed)|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNot($column, $operator = null, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereNot($column, $operator, $value, $boolean); + } + + /** + * Add an "or where not" clause to the query. + * + * @param (\Closure(static): mixed)|array|string|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNot($column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereNot($column, $operator, $value); + } + + /** + * Add an "order by" clause for a timestamp to the query. + * + * @param string|\Illuminate\Contracts\Database\Query\Expression $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function latest($column = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->latest($column); + } + + /** + * Add an "order by" clause for a timestamp to the query. + * + * @param string|\Illuminate\Contracts\Database\Query\Expression $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function oldest($column = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->oldest($column); + } + + /** + * Create a collection of models from plain arrays. + * + * @param array $items + * @return \Illuminate\Database\Eloquent\Collection + * @static + */ + public static function hydrate($items) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->hydrate($items); + } + + /** + * Insert into the database after merging the model's default attributes, setting timestamps, and casting values. + * + * @param array> $values + * @return bool + * @static + */ + public static function fillAndInsert($values) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->fillAndInsert($values); + } + + /** + * Insert (ignoring errors) into the database after merging the model's default attributes, setting timestamps, and casting values. + * + * @param array> $values + * @return int + * @static + */ + public static function fillAndInsertOrIgnore($values) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->fillAndInsertOrIgnore($values); + } + + /** + * Insert a record into the database and get its ID after merging the model's default attributes, setting timestamps, and casting values. + * + * @param array $values + * @return int + * @static + */ + public static function fillAndInsertGetId($values) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->fillAndInsertGetId($values); + } + + /** + * Enrich the given values by merging in the model's default attributes, adding timestamps, and casting values. + * + * @param array> $values + * @return array> + * @static + */ + public static function fillForInsert($values) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->fillForInsert($values); + } + + /** + * Create a collection of models from a raw query. + * + * @param string $query + * @param array $bindings + * @return \Illuminate\Database\Eloquent\Collection + * @static + */ + public static function fromQuery($query, $bindings = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->fromQuery($query, $bindings); + } + + /** + * Find a model by its primary key. + * + * @param mixed $id + * @param array|string $columns + * @return ($id is (\Illuminate\Contracts\Support\Arrayable|array) ? \Illuminate\Database\Eloquent\Collection : TModel|null) + * @static + */ + public static function find($id, $columns = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->find($id, $columns); + } + + /** + * Find a sole model by its primary key. + * + * @param mixed $id + * @param array|string $columns + * @return TModel + * @throws \Illuminate\Database\Eloquent\ModelNotFoundException + * @throws \Illuminate\Database\MultipleRecordsFoundException + * @static + */ + public static function findSole($id, $columns = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->findSole($id, $columns); + } + + /** + * Find multiple models by their primary keys. + * + * @param \Illuminate\Contracts\Support\Arrayable|array $ids + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Collection + * @static + */ + public static function findMany($ids, $columns = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->findMany($ids, $columns); + } + + /** + * Find a model by its primary key or throw an exception. + * + * @param mixed $id + * @param array|string $columns + * @return ($id is (\Illuminate\Contracts\Support\Arrayable|array) ? \Illuminate\Database\Eloquent\Collection : TModel) + * @throws \Illuminate\Database\Eloquent\ModelNotFoundException + * @static + */ + public static function findOrFail($id, $columns = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->findOrFail($id, $columns); + } + + /** + * Find a model by its primary key or return fresh model instance. + * + * @param mixed $id + * @param array|string $columns + * @return ($id is (\Illuminate\Contracts\Support\Arrayable|array) ? \Illuminate\Database\Eloquent\Collection : TModel) + * @static + */ + public static function findOrNew($id, $columns = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->findOrNew($id, $columns); + } + + /** + * Find a model by its primary key or call a callback. + * + * @template TValue + * @param mixed $id + * @param (\Closure(): TValue)|list|string $columns + * @param (\Closure(): TValue)|null $callback + * @return ( $id is (\Illuminate\Contracts\Support\Arrayable|array) + * ? \Illuminate\Database\Eloquent\Collection + * : TModel|TValue + * ) + * @static + */ + public static function findOr($id, $columns = [], $callback = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->findOr($id, $columns, $callback); + } + + /** + * Get the first record matching the attributes or instantiate it. + * + * @param array $attributes + * @param array $values + * @return TModel + * @static + */ + public static function firstOrNew($attributes = [], $values = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->firstOrNew($attributes, $values); + } + + /** + * Get the first record matching the attributes. If the record is not found, create it. + * + * @param array $attributes + * @param array $values + * @return TModel + * @static + */ + public static function firstOrCreate($attributes = [], $values = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->firstOrCreate($attributes, $values); + } + + /** + * Attempt to create the record. If a unique constraint violation occurs, attempt to find the matching record. + * + * @param array $attributes + * @param array $values + * @return TModel + * @static + */ + public static function createOrFirst($attributes = [], $values = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->createOrFirst($attributes, $values); + } + + /** + * Create or update a record matching the attributes, and fill it with values. + * + * @param array $attributes + * @param array $values + * @return TModel + * @static + */ + public static function updateOrCreate($attributes, $values = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->updateOrCreate($attributes, $values); + } + + /** + * Create a record matching the attributes, or increment the existing record. + * + * @param array $attributes + * @param string $column + * @param int|float $default + * @param int|float $step + * @param array $extra + * @return TModel + * @static + */ + public static function incrementOrCreate($attributes, $column = 'count', $default = 1, $step = 1, $extra = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->incrementOrCreate($attributes, $column, $default, $step, $extra); + } + + /** + * Execute the query and get the first result or throw an exception. + * + * @param array|string $columns + * @return TModel + * @throws \Illuminate\Database\Eloquent\ModelNotFoundException + * @static + */ + public static function firstOrFail($columns = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->firstOrFail($columns); + } + + /** + * Execute the query and get the first result or call a callback. + * + * @template TValue + * @param (\Closure(): TValue)|list $columns + * @param (\Closure(): TValue)|null $callback + * @return TModel|TValue + * @static + */ + public static function firstOr($columns = [], $callback = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->firstOr($columns, $callback); + } + + /** + * Execute the query and get the first result if it's the sole matching record. + * + * @param array|string $columns + * @return TModel + * @throws \Illuminate\Database\Eloquent\ModelNotFoundException + * @throws \Illuminate\Database\MultipleRecordsFoundException + * @static + */ + public static function sole($columns = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->sole($columns); + } + + /** + * Get a single column's value from the first result of a query. + * + * @param string|\Illuminate\Contracts\Database\Query\Expression $column + * @return mixed + * @static + */ + public static function value($column) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->value($column); + } + + /** + * Get a single column's value from the first result of a query if it's the sole matching record. + * + * @param string|\Illuminate\Contracts\Database\Query\Expression $column + * @return mixed + * @throws \Illuminate\Database\Eloquent\ModelNotFoundException + * @throws \Illuminate\Database\MultipleRecordsFoundException + * @static + */ + public static function soleValue($column) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->soleValue($column); + } + + /** + * Get a single column's value from the first result of the query or throw an exception. + * + * @param string|\Illuminate\Contracts\Database\Query\Expression $column + * @return mixed + * @throws \Illuminate\Database\Eloquent\ModelNotFoundException + * @static + */ + public static function valueOrFail($column) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->valueOrFail($column); + } + + /** + * Execute the query as a "select" statement. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Collection + * @static + */ + public static function get($columns = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->get($columns); + } + + /** + * Get the hydrated models without eager loading. + * + * @param array|string $columns + * @return array + * @static + */ + public static function getModels($columns = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->getModels($columns); + } + + /** + * Eager load the relationships for the models. + * + * @param array $models + * @return array + * @static + */ + public static function eagerLoadRelations($models) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->eagerLoadRelations($models); + } + + /** + * Register a closure to be invoked after the query is executed. + * + * @param \Closure $callback + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function afterQuery($callback) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->afterQuery($callback); + } + + /** + * Invoke the "after query" modification callbacks. + * + * @param mixed $result + * @return mixed + * @static + */ + public static function applyAfterQueryCallbacks($result) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->applyAfterQueryCallbacks($result); + } + + /** + * Get a lazy collection for the given query. + * + * @return \Illuminate\Support\LazyCollection + * @static + */ + public static function cursor() + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->cursor(); + } + + /** + * Get a collection with the values of a given column. + * + * @param string|\Illuminate\Contracts\Database\Query\Expression $column + * @param string|null $key + * @return \Illuminate\Support\Collection + * @static + */ + public static function pluck($column, $key = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->pluck($column, $key); + } + + /** + * Paginate the given query. + * + * @param int|null|\Closure $perPage + * @param array|string $columns + * @param string $pageName + * @param int|null $page + * @param \Closure|int|null $total + * @return \Illuminate\Pagination\LengthAwarePaginator + * @throws \InvalidArgumentException + * @static + */ + public static function paginate($perPage = null, $columns = [], $pageName = 'page', $page = null, $total = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->paginate($perPage, $columns, $pageName, $page, $total); + } + + /** + * Paginate the given query into a simple paginator. + * + * @param int|null $perPage + * @param array|string $columns + * @param string $pageName + * @param int|null $page + * @return \Illuminate\Contracts\Pagination\Paginator + * @static + */ + public static function simplePaginate($perPage = null, $columns = [], $pageName = 'page', $page = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->simplePaginate($perPage, $columns, $pageName, $page); + } + + /** + * Paginate the given query into a cursor paginator. + * + * @param int|null $perPage + * @param array|string $columns + * @param string $cursorName + * @param \Illuminate\Pagination\Cursor|string|null $cursor + * @return \Illuminate\Contracts\Pagination\CursorPaginator + * @static + */ + public static function cursorPaginate($perPage = null, $columns = [], $cursorName = 'cursor', $cursor = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->cursorPaginate($perPage, $columns, $cursorName, $cursor); + } + + /** + * Save a new model and return the instance. + * + * @param array $attributes + * @return TModel + * @static + */ + public static function create($attributes = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->create($attributes); + } + + /** + * Save a new model and return the instance without raising model events. + * + * @param array $attributes + * @return TModel + * @static + */ + public static function createQuietly($attributes = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->createQuietly($attributes); + } + + /** + * Save a new model and return the instance. Allow mass-assignment. + * + * @param array $attributes + * @return TModel + * @static + */ + public static function forceCreate($attributes) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->forceCreate($attributes); + } + + /** + * Save a new model instance with mass assignment without raising model events. + * + * @param array $attributes + * @return TModel + * @static + */ + public static function forceCreateQuietly($attributes = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->forceCreateQuietly($attributes); + } + + /** + * Insert new records or update the existing ones. + * + * @param array $values + * @param array|string $uniqueBy + * @param array|null $update + * @return int + * @static + */ + public static function upsert($values, $uniqueBy, $update = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->upsert($values, $uniqueBy, $update); + } + + /** + * Register a replacement for the default delete function. + * + * @param \Closure $callback + * @return void + * @static + */ + public static function onDelete($callback) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + $instance->onDelete($callback); + } + + /** + * Call the given local model scopes. + * + * @param array|string $scopes + * @return static|mixed + * @static + */ + public static function scopes($scopes) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->scopes($scopes); + } + + /** + * Apply the scopes to the Eloquent builder instance and return it. + * + * @return static + * @static + */ + public static function applyScopes() + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->applyScopes(); + } + + /** + * Prevent the specified relations from being eager loaded. + * + * @param mixed $relations + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function without($relations) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->without($relations); + } + + /** + * Set the relationships that should be eager loaded while removing any previously added eager loading specifications. + * + * @param array): mixed)|string>|string $relations + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withOnly($relations) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withOnly($relations); + } + + /** + * Create a new instance of the model being queried. + * + * @param array $attributes + * @return TModel + * @static + */ + public static function newModelInstance($attributes = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->newModelInstance($attributes); + } + + /** + * Specify attributes that should be added to any new models created by this builder. + * + * The given key / value pairs will also be added as where conditions to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|array|string $attributes + * @param mixed $value + * @param bool $asConditions + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withAttributes($attributes, $value = null, $asConditions = true) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withAttributes($attributes, $value, $asConditions); + } + + /** + * Apply query-time casts to the model instance. + * + * @param array $casts + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withCasts($casts) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withCasts($casts); + } + + /** + * Execute the given Closure within a transaction savepoint if needed. + * + * @template TModelValue + * @param \Closure(): TModelValue $scope + * @return TModelValue + * @static + */ + public static function withSavepointIfNeeded($scope) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withSavepointIfNeeded($scope); + } + + /** + * Get the underlying query builder instance. + * + * @return \Illuminate\Database\Query\Builder + * @static + */ + public static function getQuery() + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->getQuery(); + } + + /** + * Set the underlying query builder instance. + * + * @param \Illuminate\Database\Query\Builder $query + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function setQuery($query) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->setQuery($query); + } + + /** + * Get a base query builder instance. + * + * @return \Illuminate\Database\Query\Builder + * @static + */ + public static function toBase() + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->toBase(); + } + + /** + * Get the relationships being eagerly loaded. + * + * @return array + * @static + */ + public static function getEagerLoads() + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->getEagerLoads(); + } + + /** + * Set the relationships being eagerly loaded. + * + * @param array $eagerLoad + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function setEagerLoads($eagerLoad) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->setEagerLoads($eagerLoad); + } + + /** + * Indicate that the given relationships should not be eagerly loaded. + * + * @param array $relations + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withoutEagerLoad($relations) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withoutEagerLoad($relations); + } + + /** + * Flush the relationships being eagerly loaded. + * + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withoutEagerLoads() + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withoutEagerLoads(); + } + + /** + * Get the "limit" value from the query or null if it's not set. + * + * @return mixed + * @static + */ + public static function getLimit() + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->getLimit(); + } + + /** + * Get the "offset" value from the query or null if it's not set. + * + * @return mixed + * @static + */ + public static function getOffset() + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->getOffset(); + } + + /** + * Get the model instance being queried. + * + * @return TModel + * @static + */ + public static function getModel() + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->getModel(); + } + + /** + * Set a model instance for the model being queried. + * + * @template TModelNew of \Illuminate\Database\Eloquent\Model + * @param TModelNew $model + * @return static + * @static + */ + public static function setModel($model) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->setModel($model); + } + + /** + * Get the given macro by name. + * + * @param string $name + * @return \Closure + * @static + */ + public static function getMacro($name) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->getMacro($name); + } + + /** + * Checks if a macro is registered. + * + * @param string $name + * @return bool + * @static + */ + public static function hasMacro($name) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->hasMacro($name); + } + + /** + * Get the given global macro by name. + * + * @param string $name + * @return \Closure + * @static + */ + public static function getGlobalMacro($name) + { + return \Illuminate\Database\Eloquent\Builder::getGlobalMacro($name); + } + + /** + * Checks if a global macro is registered. + * + * @param string $name + * @return bool + * @static + */ + public static function hasGlobalMacro($name) + { + return \Illuminate\Database\Eloquent\Builder::hasGlobalMacro($name); + } + + /** + * Clone the Eloquent query builder. + * + * @return static + * @static + */ + public static function clone() + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->clone(); + } + + /** + * Register a closure to be invoked on a clone. + * + * @param \Closure $callback + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function onClone($callback) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->onClone($callback); + } + + /** + * Chunk the results of the query. + * + * @param int $count + * @param callable(\Illuminate\Support\Collection, int): mixed $callback + * @return bool + * @static + */ + public static function chunk($count, $callback) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->chunk($count, $callback); + } + + /** + * Run a map over each item while chunking. + * + * @template TReturn + * @param callable(TValue): TReturn $callback + * @param int $count + * @return \Illuminate\Support\Collection + * @static + */ + public static function chunkMap($callback, $count = 1000) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->chunkMap($callback, $count); + } + + /** + * Execute a callback over each item while chunking. + * + * @param callable(TValue, int): mixed $callback + * @param int $count + * @return bool + * @throws \RuntimeException + * @static + */ + public static function each($callback, $count = 1000) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->each($callback, $count); + } + + /** + * Chunk the results of a query by comparing IDs. + * + * @param int $count + * @param callable(\Illuminate\Support\Collection, int): mixed $callback + * @param string|null $column + * @param string|null $alias + * @return bool + * @static + */ + public static function chunkById($count, $callback, $column = null, $alias = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->chunkById($count, $callback, $column, $alias); + } + + /** + * Chunk the results of a query by comparing IDs in descending order. + * + * @param int $count + * @param callable(\Illuminate\Support\Collection, int): mixed $callback + * @param string|null $column + * @param string|null $alias + * @return bool + * @static + */ + public static function chunkByIdDesc($count, $callback, $column = null, $alias = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->chunkByIdDesc($count, $callback, $column, $alias); + } + + /** + * Chunk the results of a query by comparing IDs in a given order. + * + * @param int $count + * @param callable(\Illuminate\Support\Collection, int): mixed $callback + * @param string|null $column + * @param string|null $alias + * @param bool $descending + * @return bool + * @throws \RuntimeException + * @static + */ + public static function orderedChunkById($count, $callback, $column = null, $alias = null, $descending = false) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orderedChunkById($count, $callback, $column, $alias, $descending); + } + + /** + * Execute a callback over each item while chunking by ID. + * + * @param callable(TValue, int): mixed $callback + * @param int $count + * @param string|null $column + * @param string|null $alias + * @return bool + * @static + */ + public static function eachById($callback, $count = 1000, $column = null, $alias = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->eachById($callback, $count, $column, $alias); + } + + /** + * Query lazily, by chunks of the given size. + * + * @param int $chunkSize + * @return \Illuminate\Support\LazyCollection + * @throws \InvalidArgumentException + * @static + */ + public static function lazy($chunkSize = 1000) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->lazy($chunkSize); + } + + /** + * Query lazily, by chunking the results of a query by comparing IDs. + * + * @param int $chunkSize + * @param string|null $column + * @param string|null $alias + * @return \Illuminate\Support\LazyCollection + * @throws \InvalidArgumentException + * @static + */ + public static function lazyById($chunkSize = 1000, $column = null, $alias = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->lazyById($chunkSize, $column, $alias); + } + + /** + * Query lazily, by chunking the results of a query by comparing IDs in descending order. + * + * @param int $chunkSize + * @param string|null $column + * @param string|null $alias + * @return \Illuminate\Support\LazyCollection + * @throws \InvalidArgumentException + * @static + */ + public static function lazyByIdDesc($chunkSize = 1000, $column = null, $alias = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->lazyByIdDesc($chunkSize, $column, $alias); + } + + /** + * Execute the query and get the first result. + * + * @param array|string $columns + * @return TValue|null + * @static + */ + public static function first($columns = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->first($columns); + } + + /** + * Execute the query and get the first result if it's the sole matching record. + * + * @param array|string $columns + * @return TValue + * @throws \Illuminate\Database\RecordsNotFoundException + * @throws \Illuminate\Database\MultipleRecordsFoundException + * @static + */ + public static function baseSole($columns = []) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->baseSole($columns); + } + + /** + * Pass the query to a given callback and then return it. + * + * @param callable($this): mixed $callback + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function tap($callback) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->tap($callback); + } + + /** + * Pass the query to a given callback and return the result. + * + * @template TReturn + * @param (callable($this): TReturn) $callback + * @return (TReturn is null|void ? $this : TReturn) + * @static + */ + public static function pipe($callback) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->pipe($callback); + } + + /** + * Apply the callback if the given "value" is (or resolves to) truthy. + * + * @template TWhenParameter + * @template TWhenReturnType + * @param (\Closure($this): TWhenParameter)|TWhenParameter|null $value + * @param (callable($this, TWhenParameter): TWhenReturnType)|null $callback + * @param (callable($this, TWhenParameter): TWhenReturnType)|null $default + * @return $this|TWhenReturnType + * @static + */ + public static function when($value = null, $callback = null, $default = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->when($value, $callback, $default); + } + + /** + * Apply the callback if the given "value" is (or resolves to) falsy. + * + * @template TUnlessParameter + * @template TUnlessReturnType + * @param (\Closure($this): TUnlessParameter)|TUnlessParameter|null $value + * @param (callable($this, TUnlessParameter): TUnlessReturnType)|null $callback + * @param (callable($this, TUnlessParameter): TUnlessReturnType)|null $default + * @return $this|TUnlessReturnType + * @static + */ + public static function unless($value = null, $callback = null, $default = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->unless($value, $callback, $default); + } + + /** + * Add a relationship count / exists condition to the query. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation + * @param string $operator + * @param int $count + * @param string $boolean + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|null $callback + * @return \Illuminate\Database\Eloquent\Builder + * @throws \RuntimeException + * @static + */ + public static function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->has($relation, $operator, $count, $boolean, $callback); + } + + /** + * Add a relationship count / exists condition to the query with an "or". + * + * @param \Illuminate\Database\Eloquent\Relations\Relation<*, *, *>|string $relation + * @param string $operator + * @param int $count + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orHas($relation, $operator = '>=', $count = 1) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orHas($relation, $operator, $count); + } + + /** + * Add a relationship count / exists condition to the query. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation + * @param string $boolean + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|null $callback + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function doesntHave($relation, $boolean = 'and', $callback = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->doesntHave($relation, $boolean, $callback); + } + + /** + * Add a relationship count / exists condition to the query with an "or". + * + * @param \Illuminate\Database\Eloquent\Relations\Relation<*, *, *>|string $relation + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orDoesntHave($relation) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orDoesntHave($relation); + } + + /** + * Add a relationship count / exists condition to the query with where clauses. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|null $callback + * @param string $operator + * @param int $count + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereHas($relation, $callback = null, $operator = '>=', $count = 1) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereHas($relation, $callback, $operator, $count); + } + + /** + * Add a relationship count / exists condition to the query with where clauses. + * + * Also load the relationship with the same condition. + * + * @param string $relation + * @param (\Closure(\Illuminate\Database\Eloquent\Builder<*>|\Illuminate\Database\Eloquent\Relations\Relation<*, *, *>): mixed)|null $callback + * @param string $operator + * @param int $count + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withWhereHas($relation, $callback = null, $operator = '>=', $count = 1) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withWhereHas($relation, $callback, $operator, $count); + } + + /** + * Add a relationship count / exists condition to the query with where clauses and an "or". + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|null $callback + * @param string $operator + * @param int $count + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereHas($relation, $callback = null, $operator = '>=', $count = 1) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereHas($relation, $callback, $operator, $count); + } + + /** + * Add a relationship count / exists condition to the query with where clauses. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|null $callback + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereDoesntHave($relation, $callback = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereDoesntHave($relation, $callback); + } + + /** + * Add a relationship count / exists condition to the query with where clauses and an "or". + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|null $callback + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereDoesntHave($relation, $callback = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereDoesntHave($relation, $callback); + } + + /** + * Add a polymorphic relationship count / exists condition to the query. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation + * @param string|array $types + * @param string $operator + * @param int $count + * @param string $boolean + * @param (\Closure(\Illuminate\Database\Eloquent\Builder, string): mixed)|null $callback + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function hasMorph($relation, $types, $operator = '>=', $count = 1, $boolean = 'and', $callback = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->hasMorph($relation, $types, $operator, $count, $boolean, $callback); + } + + /** + * Add a polymorphic relationship count / exists condition to the query with an "or". + * + * @param \Illuminate\Database\Eloquent\Relations\MorphTo<*, *>|string $relation + * @param string|array $types + * @param string $operator + * @param int $count + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orHasMorph($relation, $types, $operator = '>=', $count = 1) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orHasMorph($relation, $types, $operator, $count); + } + + /** + * Add a polymorphic relationship count / exists condition to the query. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation + * @param string|array $types + * @param string $boolean + * @param (\Closure(\Illuminate\Database\Eloquent\Builder, string): mixed)|null $callback + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function doesntHaveMorph($relation, $types, $boolean = 'and', $callback = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->doesntHaveMorph($relation, $types, $boolean, $callback); + } + + /** + * Add a polymorphic relationship count / exists condition to the query with an "or". + * + * @param \Illuminate\Database\Eloquent\Relations\MorphTo<*, *>|string $relation + * @param string|array $types + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orDoesntHaveMorph($relation, $types) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orDoesntHaveMorph($relation, $types); + } + + /** + * Add a polymorphic relationship count / exists condition to the query with where clauses. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation + * @param string|array $types + * @param (\Closure(\Illuminate\Database\Eloquent\Builder, string): mixed)|null $callback + * @param string $operator + * @param int $count + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereHasMorph($relation, $types, $callback = null, $operator = '>=', $count = 1) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereHasMorph($relation, $types, $callback, $operator, $count); + } + + /** + * Add a polymorphic relationship count / exists condition to the query with where clauses and an "or". + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation + * @param string|array $types + * @param (\Closure(\Illuminate\Database\Eloquent\Builder, string): mixed)|null $callback + * @param string $operator + * @param int $count + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereHasMorph($relation, $types, $callback = null, $operator = '>=', $count = 1) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereHasMorph($relation, $types, $callback, $operator, $count); + } + + /** + * Add a polymorphic relationship count / exists condition to the query with where clauses. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation + * @param string|array $types + * @param (\Closure(\Illuminate\Database\Eloquent\Builder, string): mixed)|null $callback + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereDoesntHaveMorph($relation, $types, $callback = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereDoesntHaveMorph($relation, $types, $callback); + } + + /** + * Add a polymorphic relationship count / exists condition to the query with where clauses and an "or". + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation + * @param string|array $types + * @param (\Closure(\Illuminate\Database\Eloquent\Builder, string): mixed)|null $callback + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereDoesntHaveMorph($relation, $types, $callback = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereDoesntHaveMorph($relation, $types, $callback); + } + + /** + * Add a basic where clause to a relationship query. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereRelation($relation, $column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereRelation($relation, $column, $operator, $value); + } + + /** + * Add a basic where clause to a relationship query and eager-load the relationship with the same conditions. + * + * @param \Illuminate\Database\Eloquent\Relations\Relation<*, *, *>|string $relation + * @param \Closure|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withWhereRelation($relation, $column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withWhereRelation($relation, $column, $operator, $value); + } + + /** + * Add an "or where" clause to a relationship query. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereRelation($relation, $column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereRelation($relation, $column, $operator, $value); + } + + /** + * Add a basic count / exists condition to a relationship query. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereDoesntHaveRelation($relation, $column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereDoesntHaveRelation($relation, $column, $operator, $value); + } + + /** + * Add an "or where" clause to a relationship query. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereDoesntHaveRelation($relation, $column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereDoesntHaveRelation($relation, $column, $operator, $value); + } + + /** + * Add a polymorphic relationship condition to the query with a where clause. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation + * @param string|array $types + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereMorphRelation($relation, $types, $column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereMorphRelation($relation, $types, $column, $operator, $value); + } + + /** + * Add a polymorphic relationship condition to the query with an "or where" clause. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation + * @param string|array $types + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereMorphRelation($relation, $types, $column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereMorphRelation($relation, $types, $column, $operator, $value); + } + + /** + * Add a polymorphic relationship condition to the query with a doesn't have clause. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation + * @param string|array $types + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereMorphDoesntHaveRelation($relation, $types, $column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereMorphDoesntHaveRelation($relation, $types, $column, $operator, $value); + } + + /** + * Add a polymorphic relationship condition to the query with an "or doesn't have" clause. + * + * @template TRelatedModel of \Illuminate\Database\Eloquent\Model + * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation + * @param string|array $types + * @param (\Closure(\Illuminate\Database\Eloquent\Builder): mixed)|string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereMorphDoesntHaveRelation($relation, $types, $column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereMorphDoesntHaveRelation($relation, $types, $column, $operator, $value); + } + + /** + * Add a morph-to relationship condition to the query. + * + * @param \Illuminate\Database\Eloquent\Relations\MorphTo<*, *>|string $relation + * @param \Illuminate\Database\Eloquent\Model|iterable|string|null $model + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereMorphedTo($relation, $model, $boolean = 'and') + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereMorphedTo($relation, $model, $boolean); + } + + /** + * Add a not morph-to relationship condition to the query. + * + * @param \Illuminate\Database\Eloquent\Relations\MorphTo<*, *>|string $relation + * @param \Illuminate\Database\Eloquent\Model|iterable|string $model + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNotMorphedTo($relation, $model, $boolean = 'and') + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereNotMorphedTo($relation, $model, $boolean); + } + + /** + * Add a morph-to relationship condition to the query with an "or where" clause. + * + * @param \Illuminate\Database\Eloquent\Relations\MorphTo<*, *>|string $relation + * @param \Illuminate\Database\Eloquent\Model|iterable|string|null $model + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereMorphedTo($relation, $model) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereMorphedTo($relation, $model); + } + + /** + * Add a not morph-to relationship condition to the query with an "or where" clause. + * + * @param \Illuminate\Database\Eloquent\Relations\MorphTo<*, *>|string $relation + * @param \Illuminate\Database\Eloquent\Model|iterable|string $model + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNotMorphedTo($relation, $model) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereNotMorphedTo($relation, $model); + } + + /** + * Add a "belongs to" relationship where clause to the query. + * + * @param \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection $related + * @param string|null $relationshipName + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @throws \Illuminate\Database\Eloquent\RelationNotFoundException + * @static + */ + public static function whereBelongsTo($related, $relationshipName = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereBelongsTo($related, $relationshipName, $boolean); + } + + /** + * Add a "BelongsTo" relationship with an "or where" clause to the query. + * + * @param \Illuminate\Database\Eloquent\Model $related + * @param string|null $relationshipName + * @return \Illuminate\Database\Eloquent\Builder + * @throws \RuntimeException + * @static + */ + public static function orWhereBelongsTo($related, $relationshipName = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereBelongsTo($related, $relationshipName); + } + + /** + * Add a "belongs to many" relationship where clause to the query. + * + * @param \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection $related + * @param string|null $relationshipName + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @throws \Illuminate\Database\Eloquent\RelationNotFoundException + * @static + */ + public static function whereAttachedTo($related, $relationshipName = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->whereAttachedTo($related, $relationshipName, $boolean); + } + + /** + * Add a "belongs to many" relationship with an "or where" clause to the query. + * + * @param \Illuminate\Database\Eloquent\Model $related + * @param string|null $relationshipName + * @return \Illuminate\Database\Eloquent\Builder + * @throws \RuntimeException + * @static + */ + public static function orWhereAttachedTo($related, $relationshipName = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->orWhereAttachedTo($related, $relationshipName); + } + + /** + * Add subselect queries to include an aggregate value for a relationship. + * + * @param mixed $relations + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param string $function + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withAggregate($relations, $column, $function = null) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withAggregate($relations, $column, $function); + } + + /** + * Add subselect queries to count the relations. + * + * @param mixed $relations + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withCount($relations) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withCount($relations); + } + + /** + * Add subselect queries to include the max of the relation's column. + * + * @param string|array $relation + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withMax($relation, $column) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withMax($relation, $column); + } + + /** + * Add subselect queries to include the min of the relation's column. + * + * @param string|array $relation + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withMin($relation, $column) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withMin($relation, $column); + } + + /** + * Add subselect queries to include the sum of the relation's column. + * + * @param string|array $relation + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withSum($relation, $column) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withSum($relation, $column); + } + + /** + * Add subselect queries to include the average of the relation's column. + * + * @param string|array $relation + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withAvg($relation, $column) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withAvg($relation, $column); + } + + /** + * Add subselect queries to include the existence of related models. + * + * @param string|array $relation + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function withExists($relation) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->withExists($relation); + } + + /** + * Merge the where constraints from another query to the current query. + * + * @param \Illuminate\Database\Eloquent\Builder<*> $from + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function mergeConstraintsFrom($from) + { + /** @var \Illuminate\Database\Eloquent\Builder $instance */ + return $instance->mergeConstraintsFrom($from); + } + + /** + * Set the columns to be selected. + * + * @param mixed $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function select($columns = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->select($columns); + } + + /** + * Add a subselect expression to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|string $query + * @param string $as + * @return \Illuminate\Database\Eloquent\Builder + * @throws \InvalidArgumentException + * @static + */ + public static function selectSub($query, $as) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->selectSub($query, $as); + } + + /** + * Add a new "raw" select expression to the query. + * + * @param string $expression + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function selectRaw($expression, $bindings = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->selectRaw($expression, $bindings); + } + + /** + * Makes "from" fetch from a subquery. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|string $query + * @param string $as + * @return \Illuminate\Database\Eloquent\Builder + * @throws \InvalidArgumentException + * @static + */ + public static function fromSub($query, $as) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->fromSub($query, $as); + } + + /** + * Add a raw from clause to the query. + * + * @param string $expression + * @param mixed $bindings + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function fromRaw($expression, $bindings = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->fromRaw($expression, $bindings); + } + + /** + * Add a new select column to the query. + * + * @param mixed $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function addSelect($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->addSelect($column); + } + + /** + * Force the query to only return distinct results. + * + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function distinct() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->distinct(); + } + + /** + * Set the table which the query is targeting. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|\Illuminate\Contracts\Database\Query\Expression|string $table + * @param string|null $as + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function from($table, $as = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->from($table, $as); + } + + /** + * Add an index hint to suggest a query index. + * + * @param string $index + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function useIndex($index) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->useIndex($index); + } + + /** + * Add an index hint to force a query index. + * + * @param string $index + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function forceIndex($index) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->forceIndex($index); + } + + /** + * Add an index hint to ignore a query index. + * + * @param string $index + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function ignoreIndex($index) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->ignoreIndex($index); + } + + /** + * Add a join clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $table + * @param \Closure|\Illuminate\Contracts\Database\Query\Expression|string $first + * @param string|null $operator + * @param \Illuminate\Contracts\Database\Query\Expression|string|null $second + * @param string $type + * @param bool $where + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function join($table, $first, $operator = null, $second = null, $type = 'inner', $where = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->join($table, $first, $operator, $second, $type, $where); + } + + /** + * Add a "join where" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $table + * @param \Closure|\Illuminate\Contracts\Database\Query\Expression|string $first + * @param string $operator + * @param \Illuminate\Contracts\Database\Query\Expression|string $second + * @param string $type + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function joinWhere($table, $first, $operator, $second, $type = 'inner') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->joinWhere($table, $first, $operator, $second, $type); + } + + /** + * Add a subquery join clause to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|string $query + * @param string $as + * @param \Closure|\Illuminate\Contracts\Database\Query\Expression|string $first + * @param string|null $operator + * @param \Illuminate\Contracts\Database\Query\Expression|string|null $second + * @param string $type + * @param bool $where + * @return \Illuminate\Database\Eloquent\Builder + * @throws \InvalidArgumentException + * @static + */ + public static function joinSub($query, $as, $first, $operator = null, $second = null, $type = 'inner', $where = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->joinSub($query, $as, $first, $operator, $second, $type, $where); + } + + /** + * Add a lateral join clause to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|string $query + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function joinLateral($query, $as, $type = 'inner') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->joinLateral($query, $as, $type); + } + + /** + * Add a lateral left join to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|string $query + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function leftJoinLateral($query, $as) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->leftJoinLateral($query, $as); + } + + /** + * Add a left join to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $table + * @param \Closure|\Illuminate\Contracts\Database\Query\Expression|string $first + * @param string|null $operator + * @param \Illuminate\Contracts\Database\Query\Expression|string|null $second + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function leftJoin($table, $first, $operator = null, $second = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->leftJoin($table, $first, $operator, $second); + } + + /** + * Add a "join where" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $table + * @param \Closure|\Illuminate\Contracts\Database\Query\Expression|string $first + * @param string $operator + * @param \Illuminate\Contracts\Database\Query\Expression|string|null $second + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function leftJoinWhere($table, $first, $operator, $second) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->leftJoinWhere($table, $first, $operator, $second); + } + + /** + * Add a subquery left join to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|string $query + * @param string $as + * @param \Closure|\Illuminate\Contracts\Database\Query\Expression|string $first + * @param string|null $operator + * @param \Illuminate\Contracts\Database\Query\Expression|string|null $second + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function leftJoinSub($query, $as, $first, $operator = null, $second = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->leftJoinSub($query, $as, $first, $operator, $second); + } + + /** + * Add a right join to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $table + * @param \Closure|string $first + * @param string|null $operator + * @param \Illuminate\Contracts\Database\Query\Expression|string|null $second + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function rightJoin($table, $first, $operator = null, $second = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->rightJoin($table, $first, $operator, $second); + } + + /** + * Add a "right join where" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $table + * @param \Closure|\Illuminate\Contracts\Database\Query\Expression|string $first + * @param string $operator + * @param \Illuminate\Contracts\Database\Query\Expression|string $second + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function rightJoinWhere($table, $first, $operator, $second) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->rightJoinWhere($table, $first, $operator, $second); + } + + /** + * Add a subquery right join to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|string $query + * @param string $as + * @param \Closure|\Illuminate\Contracts\Database\Query\Expression|string $first + * @param string|null $operator + * @param \Illuminate\Contracts\Database\Query\Expression|string|null $second + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function rightJoinSub($query, $as, $first, $operator = null, $second = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->rightJoinSub($query, $as, $first, $operator, $second); + } + + /** + * Add a "cross join" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $table + * @param \Closure|\Illuminate\Contracts\Database\Query\Expression|string|null $first + * @param string|null $operator + * @param \Illuminate\Contracts\Database\Query\Expression|string|null $second + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function crossJoin($table, $first = null, $operator = null, $second = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->crossJoin($table, $first, $operator, $second); + } + + /** + * Add a subquery cross join to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|string $query + * @param string $as + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function crossJoinSub($query, $as) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->crossJoinSub($query, $as); + } + + /** + * Merge an array of where clauses and bindings. + * + * @param array $wheres + * @param array $bindings + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function mergeWheres($wheres, $bindings) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->mergeWheres($wheres, $bindings); + } + + /** + * Prepare the value and operator for a where clause. + * + * @param string $value + * @param string $operator + * @param bool $useDefault + * @return array + * @throws \InvalidArgumentException + * @static + */ + public static function prepareValueAndOperator($value, $operator, $useDefault = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->prepareValueAndOperator($value, $operator, $useDefault); + } + + /** + * Add a "where" clause comparing two columns to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string|array $first + * @param string|null $operator + * @param string|null $second + * @param string|null $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereColumn($first, $operator = null, $second = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereColumn($first, $operator, $second, $boolean); + } + + /** + * Add an "or where" clause comparing two columns to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string|array $first + * @param string|null $operator + * @param string|null $second + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereColumn($first, $operator = null, $second = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereColumn($first, $operator, $second); + } + + /** + * Add a raw where clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $sql + * @param mixed $bindings + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereRaw($sql, $bindings = [], $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereRaw($sql, $bindings, $boolean); + } + + /** + * Add a raw or where clause to the query. + * + * @param string $sql + * @param mixed $bindings + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereRaw($sql, $bindings = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereRaw($sql, $bindings); + } + + /** + * Add a "where like" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param string $value + * @param bool $caseSensitive + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereLike($column, $value, $caseSensitive = false, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereLike($column, $value, $caseSensitive, $boolean, $not); + } + + /** + * Add an "or where like" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param string $value + * @param bool $caseSensitive + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereLike($column, $value, $caseSensitive = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereLike($column, $value, $caseSensitive); + } + + /** + * Add a "where not like" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param string $value + * @param bool $caseSensitive + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNotLike($column, $value, $caseSensitive = false, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereNotLike($column, $value, $caseSensitive, $boolean); + } + + /** + * Add an "or where not like" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param string $value + * @param bool $caseSensitive + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNotLike($column, $value, $caseSensitive = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereNotLike($column, $value, $caseSensitive); + } + + /** + * Add a "where in" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param mixed $values + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereIn($column, $values, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereIn($column, $values, $boolean, $not); + } + + /** + * Add an "or where in" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param mixed $values + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereIn($column, $values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereIn($column, $values); + } + + /** + * Add a "where not in" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param mixed $values + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNotIn($column, $values, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereNotIn($column, $values, $boolean); + } + + /** + * Add an "or where not in" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param mixed $values + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNotIn($column, $values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereNotIn($column, $values); + } + + /** + * Add a "where in raw" clause for integer values to the query. + * + * @param string $column + * @param \Illuminate\Contracts\Support\Arrayable|array $values + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereIntegerInRaw($column, $values, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereIntegerInRaw($column, $values, $boolean, $not); + } + + /** + * Add an "or where in raw" clause for integer values to the query. + * + * @param string $column + * @param \Illuminate\Contracts\Support\Arrayable|array $values + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereIntegerInRaw($column, $values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereIntegerInRaw($column, $values); + } + + /** + * Add a "where not in raw" clause for integer values to the query. + * + * @param string $column + * @param \Illuminate\Contracts\Support\Arrayable|array $values + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereIntegerNotInRaw($column, $values, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereIntegerNotInRaw($column, $values, $boolean); + } + + /** + * Add an "or where not in raw" clause for integer values to the query. + * + * @param string $column + * @param \Illuminate\Contracts\Support\Arrayable|array $values + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereIntegerNotInRaw($column, $values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereIntegerNotInRaw($column, $values); + } + + /** + * Add a "where null" clause to the query. + * + * @param string|array|\Illuminate\Contracts\Database\Query\Expression $columns + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNull($columns, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereNull($columns, $boolean, $not); + } + + /** + * Add an "or where null" clause to the query. + * + * @param string|array|\Illuminate\Contracts\Database\Query\Expression $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNull($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereNull($column); + } + + /** + * Add a "where not null" clause to the query. + * + * @param string|array|\Illuminate\Contracts\Database\Query\Expression $columns + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNotNull($columns, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereNotNull($columns, $boolean); + } + + /** + * Add a where between statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereBetween($column, $values, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereBetween($column, $values, $boolean, $not); + } + + /** + * Add a where between statement using columns to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereBetweenColumns($column, $values, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereBetweenColumns($column, $values, $boolean, $not); + } + + /** + * Add an or where between statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereBetween($column, $values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereBetween($column, $values); + } + + /** + * Add an or where between statement using columns to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereBetweenColumns($column, $values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereBetweenColumns($column, $values); + } + + /** + * Add a where not between statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNotBetween($column, $values, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereNotBetween($column, $values, $boolean); + } + + /** + * Add a where not between statement using columns to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNotBetweenColumns($column, $values, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereNotBetweenColumns($column, $values, $boolean); + } + + /** + * Add an or where not between statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNotBetween($column, $values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereNotBetween($column, $values); + } + + /** + * Add an or where not between statement using columns to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNotBetweenColumns($column, $values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereNotBetweenColumns($column, $values); + } + + /** + * Add an "or where not null" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNotNull($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereNotNull($column); + } + + /** + * Add a "where date" statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param \DateTimeInterface|string|null $operator + * @param \DateTimeInterface|string|null $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereDate($column, $operator, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereDate($column, $operator, $value, $boolean); + } + + /** + * Add an "or where date" statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param \DateTimeInterface|string|null $operator + * @param \DateTimeInterface|string|null $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereDate($column, $operator, $value = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereDate($column, $operator, $value); + } + + /** + * Add a "where time" statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param \DateTimeInterface|string|null $operator + * @param \DateTimeInterface|string|null $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereTime($column, $operator, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereTime($column, $operator, $value, $boolean); + } + + /** + * Add an "or where time" statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param \DateTimeInterface|string|null $operator + * @param \DateTimeInterface|string|null $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereTime($column, $operator, $value = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereTime($column, $operator, $value); + } + + /** + * Add a "where day" statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param \DateTimeInterface|string|int|null $operator + * @param \DateTimeInterface|string|int|null $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereDay($column, $operator, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereDay($column, $operator, $value, $boolean); + } + + /** + * Add an "or where day" statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param \DateTimeInterface|string|int|null $operator + * @param \DateTimeInterface|string|int|null $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereDay($column, $operator, $value = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereDay($column, $operator, $value); + } + + /** + * Add a "where month" statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param \DateTimeInterface|string|int|null $operator + * @param \DateTimeInterface|string|int|null $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereMonth($column, $operator, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereMonth($column, $operator, $value, $boolean); + } + + /** + * Add an "or where month" statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param \DateTimeInterface|string|int|null $operator + * @param \DateTimeInterface|string|int|null $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereMonth($column, $operator, $value = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereMonth($column, $operator, $value); + } + + /** + * Add a "where year" statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param \DateTimeInterface|string|int|null $operator + * @param \DateTimeInterface|string|int|null $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereYear($column, $operator, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereYear($column, $operator, $value, $boolean); + } + + /** + * Add an "or where year" statement to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @param \DateTimeInterface|string|int|null $operator + * @param \DateTimeInterface|string|int|null $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereYear($column, $operator, $value = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereYear($column, $operator, $value); + } + + /** + * Add a nested where statement to the query. + * + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNested($callback, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereNested($callback, $boolean); + } + + /** + * Create a new query instance for nested where condition. + * + * @return \Illuminate\Database\Query\Builder + * @static + */ + public static function forNestedWhere() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->forNestedWhere(); + } + + /** + * Add another query builder as a nested where to the query builder. + * + * @param \Illuminate\Database\Query\Builder $query + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function addNestedWhereQuery($query, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->addNestedWhereQuery($query, $boolean); + } + + /** + * Add an exists clause to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*> $callback + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereExists($callback, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereExists($callback, $boolean, $not); + } + + /** + * Add an or exists clause to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*> $callback + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereExists($callback, $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereExists($callback, $not); + } + + /** + * Add a where not exists clause to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*> $callback + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNotExists($callback, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereNotExists($callback, $boolean); + } + + /** + * Add a where not exists clause to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*> $callback + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNotExists($callback) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereNotExists($callback); + } + + /** + * Add an exists clause to the query. + * + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function addWhereExistsQuery($query, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->addWhereExistsQuery($query, $boolean, $not); + } + + /** + * Adds a where condition using row values. + * + * @param array $columns + * @param string $operator + * @param array $values + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @throws \InvalidArgumentException + * @static + */ + public static function whereRowValues($columns, $operator, $values, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereRowValues($columns, $operator, $values, $boolean); + } + + /** + * Adds an or where condition using row values. + * + * @param array $columns + * @param string $operator + * @param array $values + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereRowValues($columns, $operator, $values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereRowValues($columns, $operator, $values); + } + + /** + * Add a "where JSON contains" clause to the query. + * + * @param string $column + * @param mixed $value + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereJsonContains($column, $value, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereJsonContains($column, $value, $boolean, $not); + } + + /** + * Add an "or where JSON contains" clause to the query. + * + * @param string $column + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereJsonContains($column, $value) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereJsonContains($column, $value); + } + + /** + * Add a "where JSON not contains" clause to the query. + * + * @param string $column + * @param mixed $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereJsonDoesntContain($column, $value, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereJsonDoesntContain($column, $value, $boolean); + } + + /** + * Add an "or where JSON not contains" clause to the query. + * + * @param string $column + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereJsonDoesntContain($column, $value) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereJsonDoesntContain($column, $value); + } + + /** + * Add a "where JSON overlaps" clause to the query. + * + * @param string $column + * @param mixed $value + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereJsonOverlaps($column, $value, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereJsonOverlaps($column, $value, $boolean, $not); + } + + /** + * Add an "or where JSON overlaps" clause to the query. + * + * @param string $column + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereJsonOverlaps($column, $value) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereJsonOverlaps($column, $value); + } + + /** + * Add a "where JSON not overlap" clause to the query. + * + * @param string $column + * @param mixed $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereJsonDoesntOverlap($column, $value, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereJsonDoesntOverlap($column, $value, $boolean); + } + + /** + * Add an "or where JSON not overlap" clause to the query. + * + * @param string $column + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereJsonDoesntOverlap($column, $value) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereJsonDoesntOverlap($column, $value); + } + + /** + * Add a clause that determines if a JSON path exists to the query. + * + * @param string $column + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereJsonContainsKey($column, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereJsonContainsKey($column, $boolean, $not); + } + + /** + * Add an "or" clause that determines if a JSON path exists to the query. + * + * @param string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereJsonContainsKey($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereJsonContainsKey($column); + } + + /** + * Add a clause that determines if a JSON path does not exist to the query. + * + * @param string $column + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereJsonDoesntContainKey($column, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereJsonDoesntContainKey($column, $boolean); + } + + /** + * Add an "or" clause that determines if a JSON path does not exist to the query. + * + * @param string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereJsonDoesntContainKey($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereJsonDoesntContainKey($column); + } + + /** + * Add a "where JSON length" clause to the query. + * + * @param string $column + * @param mixed $operator + * @param mixed $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereJsonLength($column, $operator, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereJsonLength($column, $operator, $value, $boolean); + } + + /** + * Add an "or where JSON length" clause to the query. + * + * @param string $column + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereJsonLength($column, $operator, $value = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereJsonLength($column, $operator, $value); + } + + /** + * Handles dynamic "where" clauses to the query. + * + * @param string $method + * @param array $parameters + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function dynamicWhere($method, $parameters) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->dynamicWhere($method, $parameters); + } + + /** + * Add a "where fulltext" clause to the query. + * + * @param string|string[] $columns + * @param string $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereFullText($columns, $value, $options = [], $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereFullText($columns, $value, $options, $boolean); + } + + /** + * Add a "or where fulltext" clause to the query. + * + * @param string|string[] $columns + * @param string $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereFullText($columns, $value, $options = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereFullText($columns, $value, $options); + } + + /** + * Add a "where" clause to the query for multiple columns with "and" conditions between them. + * + * @param \Illuminate\Contracts\Database\Query\Expression[]|\Closure[]|string[] $columns + * @param mixed $operator + * @param mixed $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereAll($columns, $operator = null, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereAll($columns, $operator, $value, $boolean); + } + + /** + * Add an "or where" clause to the query for multiple columns with "and" conditions between them. + * + * @param \Illuminate\Contracts\Database\Query\Expression[]|\Closure[]|string[] $columns + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereAll($columns, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereAll($columns, $operator, $value); + } + + /** + * Add a "where" clause to the query for multiple columns with "or" conditions between them. + * + * @param \Illuminate\Contracts\Database\Query\Expression[]|\Closure[]|string[] $columns + * @param mixed $operator + * @param mixed $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereAny($columns, $operator = null, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereAny($columns, $operator, $value, $boolean); + } + + /** + * Add an "or where" clause to the query for multiple columns with "or" conditions between them. + * + * @param \Illuminate\Contracts\Database\Query\Expression[]|\Closure[]|string[] $columns + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereAny($columns, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereAny($columns, $operator, $value); + } + + /** + * Add a "where not" clause to the query for multiple columns where none of the conditions should be true. + * + * @param \Illuminate\Contracts\Database\Query\Expression[]|\Closure[]|string[] $columns + * @param mixed $operator + * @param mixed $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNone($columns, $operator = null, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereNone($columns, $operator, $value, $boolean); + } + + /** + * Add an "or where not" clause to the query for multiple columns where none of the conditions should be true. + * + * @param \Illuminate\Contracts\Database\Query\Expression[]|\Closure[]|string[] $columns + * @param mixed $operator + * @param mixed $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNone($columns, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereNone($columns, $operator, $value); + } + + /** + * Add a "group by" clause to the query. + * + * @param array|\Illuminate\Contracts\Database\Query\Expression|string $groups + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function groupBy(...$groups) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->groupBy(...$groups); + } + + /** + * Add a raw groupBy clause to the query. + * + * @param string $sql + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function groupByRaw($sql, $bindings = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->groupByRaw($sql, $bindings); + } + + /** + * Add a "having" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|\Closure|string $column + * @param \DateTimeInterface|string|int|float|null $operator + * @param \Illuminate\Contracts\Database\Query\Expression|\DateTimeInterface|string|int|float|null $value + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function having($column, $operator = null, $value = null, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->having($column, $operator, $value, $boolean); + } + + /** + * Add an "or having" clause to the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|\Closure|string $column + * @param \DateTimeInterface|string|int|float|null $operator + * @param \Illuminate\Contracts\Database\Query\Expression|\DateTimeInterface|string|int|float|null $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orHaving($column, $operator = null, $value = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orHaving($column, $operator, $value); + } + + /** + * Add a nested having statement to the query. + * + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function havingNested($callback, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->havingNested($callback, $boolean); + } + + /** + * Add another query builder as a nested having to the query builder. + * + * @param \Illuminate\Database\Query\Builder $query + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function addNestedHavingQuery($query, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->addNestedHavingQuery($query, $boolean); + } + + /** + * Add a "having null" clause to the query. + * + * @param array|string $columns + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function havingNull($columns, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->havingNull($columns, $boolean, $not); + } + + /** + * Add an "or having null" clause to the query. + * + * @param string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orHavingNull($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orHavingNull($column); + } + + /** + * Add a "having not null" clause to the query. + * + * @param array|string $columns + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function havingNotNull($columns, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->havingNotNull($columns, $boolean); + } + + /** + * Add an "or having not null" clause to the query. + * + * @param string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orHavingNotNull($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orHavingNotNull($column); + } + + /** + * Add a "having between " clause to the query. + * + * @param string $column + * @param string $boolean + * @param bool $not + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function havingBetween($column, $values, $boolean = 'and', $not = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->havingBetween($column, $values, $boolean, $not); + } + + /** + * Add a raw having clause to the query. + * + * @param string $sql + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function havingRaw($sql, $bindings = [], $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->havingRaw($sql, $bindings, $boolean); + } + + /** + * Add a raw or having clause to the query. + * + * @param string $sql + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orHavingRaw($sql, $bindings = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orHavingRaw($sql, $bindings); + } + + /** + * Add an "order by" clause to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|\Illuminate\Contracts\Database\Query\Expression|string $column + * @param string $direction + * @return \Illuminate\Database\Eloquent\Builder + * @throws \InvalidArgumentException + * @static + */ + public static function orderBy($column, $direction = 'asc') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orderBy($column, $direction); + } + + /** + * Add a descending "order by" clause to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|\Illuminate\Contracts\Database\Query\Expression|string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orderByDesc($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orderByDesc($column); + } + + /** + * Put the query's results in random order. + * + * @param string|int $seed + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function inRandomOrder($seed = '') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->inRandomOrder($seed); + } + + /** + * Add a raw "order by" clause to the query. + * + * @param string $sql + * @param array $bindings + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orderByRaw($sql, $bindings = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orderByRaw($sql, $bindings); + } + + /** + * Alias to set the "offset" value of the query. + * + * @param int $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function skip($value) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->skip($value); + } + + /** + * Set the "offset" value of the query. + * + * @param int $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function offset($value) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->offset($value); + } + + /** + * Alias to set the "limit" value of the query. + * + * @param int $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function take($value) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->take($value); + } + + /** + * Set the "limit" value of the query. + * + * @param int $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function limit($value) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->limit($value); + } + + /** + * Add a "group limit" clause to the query. + * + * @param int $value + * @param string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function groupLimit($value, $column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->groupLimit($value, $column); + } + + /** + * Set the limit and offset for a given page. + * + * @param int $page + * @param int $perPage + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function forPage($page, $perPage = 15) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->forPage($page, $perPage); + } + + /** + * Constrain the query to the previous "page" of results before a given ID. + * + * @param int $perPage + * @param int|null $lastId + * @param string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function forPageBeforeId($perPage = 15, $lastId = 0, $column = 'id') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->forPageBeforeId($perPage, $lastId, $column); + } + + /** + * Constrain the query to the next "page" of results after a given ID. + * + * @param int $perPage + * @param int|null $lastId + * @param string $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function forPageAfterId($perPage = 15, $lastId = 0, $column = 'id') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->forPageAfterId($perPage, $lastId, $column); + } + + /** + * Remove all existing orders and optionally add a new order. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Contracts\Database\Query\Expression|string|null $column + * @param string $direction + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function reorder($column = null, $direction = 'asc') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->reorder($column, $direction); + } + + /** + * Add descending "reorder" clause to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Contracts\Database\Query\Expression|string|null $column + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function reorderDesc($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->reorderDesc($column); + } + + /** + * Add a union statement to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*> $query + * @param bool $all + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function union($query, $all = false) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->union($query, $all); + } + + /** + * Add a union all statement to the query. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*> $query + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function unionAll($query) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->unionAll($query); + } + + /** + * Lock the selected rows in the table. + * + * @param string|bool $value + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function lock($value = true) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->lock($value); + } + + /** + * Lock the selected rows in the table for updating. + * + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function lockForUpdate() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->lockForUpdate(); + } + + /** + * Share lock the selected rows in the table. + * + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function sharedLock() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->sharedLock(); + } + + /** + * Register a closure to be invoked before the query is executed. + * + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function beforeQuery($callback) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->beforeQuery($callback); + } + + /** + * Invoke the "before query" modification callbacks. + * + * @return void + * @static + */ + public static function applyBeforeQueryCallbacks() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + $instance->applyBeforeQueryCallbacks(); + } + + /** + * Get the SQL representation of the query. + * + * @return string + * @static + */ + public static function toSql() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->toSql(); + } + + /** + * Get the raw SQL representation of the query with embedded bindings. + * + * @return string + * @static + */ + public static function toRawSql() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->toRawSql(); + } + + /** + * Get a single expression value from the first result of a query. + * + * @return mixed + * @static + */ + public static function rawValue($expression, $bindings = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->rawValue($expression, $bindings); + } + + /** + * Get the count of the total records for the paginator. + * + * @param array $columns + * @return int<0, max> + * @static + */ + public static function getCountForPagination($columns = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->getCountForPagination($columns); + } + + /** + * Concatenate values of a given column as a string. + * + * @param string $column + * @param string $glue + * @return string + * @static + */ + public static function implode($column, $glue = '') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->implode($column, $glue); + } + + /** + * Determine if any rows exist for the current query. + * + * @return bool + * @static + */ + public static function exists() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->exists(); + } + + /** + * Determine if no rows exist for the current query. + * + * @return bool + * @static + */ + public static function doesntExist() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->doesntExist(); + } + + /** + * Execute the given callback if no rows exist for the current query. + * + * @return mixed + * @static + */ + public static function existsOr($callback) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->existsOr($callback); + } + + /** + * Execute the given callback if rows exist for the current query. + * + * @return mixed + * @static + */ + public static function doesntExistOr($callback) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->doesntExistOr($callback); + } + + /** + * Retrieve the "count" result of the query. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $columns + * @return int<0, max> + * @static + */ + public static function count($columns = '*') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->count($columns); + } + + /** + * Retrieve the minimum value of a given column. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return mixed + * @static + */ + public static function min($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->min($column); + } + + /** + * Retrieve the maximum value of a given column. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return mixed + * @static + */ + public static function max($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->max($column); + } + + /** + * Retrieve the sum of the values of a given column. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return mixed + * @static + */ + public static function sum($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->sum($column); + } + + /** + * Retrieve the average of the values of a given column. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return mixed + * @static + */ + public static function avg($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->avg($column); + } + + /** + * Alias for the "avg" method. + * + * @param \Illuminate\Contracts\Database\Query\Expression|string $column + * @return mixed + * @static + */ + public static function average($column) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->average($column); + } + + /** + * Execute an aggregate function on the database. + * + * @param string $function + * @param array $columns + * @return mixed + * @static + */ + public static function aggregate($function, $columns = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->aggregate($function, $columns); + } + + /** + * Execute a numeric aggregate function on the database. + * + * @param string $function + * @param array $columns + * @return float|int + * @static + */ + public static function numericAggregate($function, $columns = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->numericAggregate($function, $columns); + } + + /** + * Insert new records into the database. + * + * @return bool + * @static + */ + public static function insert($values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->insert($values); + } + + /** + * Insert new records into the database while ignoring errors. + * + * @return int<0, max> + * @static + */ + public static function insertOrIgnore($values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->insertOrIgnore($values); + } + + /** + * Insert a new record and get the value of the primary key. + * + * @param string|null $sequence + * @return int + * @static + */ + public static function insertGetId($values, $sequence = null) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->insertGetId($values, $sequence); + } + + /** + * Insert new records into the table using a subquery. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|string $query + * @return int + * @static + */ + public static function insertUsing($columns, $query) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->insertUsing($columns, $query); + } + + /** + * Insert new records into the table using a subquery while ignoring errors. + * + * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder<*>|string $query + * @return int + * @static + */ + public static function insertOrIgnoreUsing($columns, $query) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->insertOrIgnoreUsing($columns, $query); + } + + /** + * Update records in a PostgreSQL database using the update from syntax. + * + * @return int + * @static + */ + public static function updateFrom($values) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->updateFrom($values); + } + + /** + * Insert or update a record matching the attributes, and fill it with values. + * + * @return bool + * @static + */ + public static function updateOrInsert($attributes, $values = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->updateOrInsert($attributes, $values); + } + + /** + * Increment the given column's values by the given amounts. + * + * @param array $columns + * @param array $extra + * @return int<0, max> + * @throws \InvalidArgumentException + * @static + */ + public static function incrementEach($columns, $extra = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->incrementEach($columns, $extra); + } + + /** + * Decrement the given column's values by the given amounts. + * + * @param array $columns + * @param array $extra + * @return int<0, max> + * @throws \InvalidArgumentException + * @static + */ + public static function decrementEach($columns, $extra = []) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->decrementEach($columns, $extra); + } + + /** + * Run a truncate statement on the table. + * + * @return void + * @static + */ + public static function truncate() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + $instance->truncate(); + } + + /** + * Get all of the query builder's columns in a text-only array with all expressions evaluated. + * + * @return list + * @static + */ + public static function getColumns() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->getColumns(); + } + + /** + * Create a raw database expression. + * + * @param mixed $value + * @return \Illuminate\Contracts\Database\Query\Expression + * @static + */ + public static function raw($value) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->raw($value); + } + + /** + * Get the current query value bindings in a flattened array. + * + * @return list + * @static + */ + public static function getBindings() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->getBindings(); + } + + /** + * Get the raw array of bindings. + * + * @return \Illuminate\Database\Query\array{ select: list, + * from: list, + * join: list, + * where: list, + * groupBy: list, + * having: list, + * order: list, + * union: list, + * unionOrder: list, + * } + * @static + */ + public static function getRawBindings() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->getRawBindings(); + } + + /** + * Set the bindings on the query builder. + * + * @param list $bindings + * @param "select"|"from"|"join"|"where"|"groupBy"|"having"|"order"|"union"|"unionOrder" $type + * @return \Illuminate\Database\Eloquent\Builder + * @throws \InvalidArgumentException + * @static + */ + public static function setBindings($bindings, $type = 'where') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->setBindings($bindings, $type); + } + + /** + * Add a binding to the query. + * + * @param mixed $value + * @param "select"|"from"|"join"|"where"|"groupBy"|"having"|"order"|"union"|"unionOrder" $type + * @return \Illuminate\Database\Eloquent\Builder + * @throws \InvalidArgumentException + * @static + */ + public static function addBinding($value, $type = 'where') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->addBinding($value, $type); + } + + /** + * Cast the given binding value. + * + * @param mixed $value + * @return mixed + * @static + */ + public static function castBinding($value) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->castBinding($value); + } + + /** + * Merge an array of bindings into our bindings. + * + * @param self $query + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function mergeBindings($query) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->mergeBindings($query); + } + + /** + * Remove all of the expressions from a list of bindings. + * + * @param array $bindings + * @return list + * @static + */ + public static function cleanBindings($bindings) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->cleanBindings($bindings); + } + + /** + * Get the database query processor instance. + * + * @return \Illuminate\Database\Query\Processors\Processor + * @static + */ + public static function getProcessor() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->getProcessor(); + } + + /** + * Get the query grammar instance. + * + * @return \Illuminate\Database\Query\Grammars\Grammar + * @static + */ + public static function getGrammar() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->getGrammar(); + } + + /** + * Use the "write" PDO connection when executing the query. + * + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function useWritePdo() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->useWritePdo(); + } + + /** + * Clone the query without the given properties. + * + * @return static + * @static + */ + public static function cloneWithout($properties) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->cloneWithout($properties); + } + + /** + * Clone the query without the given bindings. + * + * @return static + * @static + */ + public static function cloneWithoutBindings($except) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->cloneWithoutBindings($except); + } + + /** + * Dump the current SQL and bindings. + * + * @param mixed $args + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function dump(...$args) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->dump(...$args); + } + + /** + * Dump the raw current SQL with embedded bindings. + * + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function dumpRawSql() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->dumpRawSql(); + } + + /** + * Die and dump the current SQL and bindings. + * + * @return never + * @static + */ + public static function dd() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->dd(); + } + + /** + * Die and dump the current SQL with embedded bindings. + * + * @return never + * @static + */ + public static function ddRawSql() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->ddRawSql(); + } + + /** + * Add a where clause to determine if a "date" column is in the past to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function wherePast($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->wherePast($columns); + } + + /** + * Add a where clause to determine if a "date" column is in the past or now to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNowOrPast($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereNowOrPast($columns); + } + + /** + * Add an "or where" clause to determine if a "date" column is in the past to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWherePast($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWherePast($columns); + } + + /** + * Add a where clause to determine if a "date" column is in the past or now to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNowOrPast($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereNowOrPast($columns); + } + + /** + * Add a where clause to determine if a "date" column is in the future to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereFuture($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereFuture($columns); + } + + /** + * Add a where clause to determine if a "date" column is in the future or now to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereNowOrFuture($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereNowOrFuture($columns); + } + + /** + * Add an "or where" clause to determine if a "date" column is in the future to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereFuture($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereFuture($columns); + } + + /** + * Add an "or where" clause to determine if a "date" column is in the future or now to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereNowOrFuture($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereNowOrFuture($columns); + } + + /** + * Add a "where date" clause to determine if a "date" column is today to the query. + * + * @param array|string $columns + * @param string $boolean + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereToday($columns, $boolean = 'and') + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereToday($columns, $boolean); + } + + /** + * Add a "where date" clause to determine if a "date" column is before today. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereBeforeToday($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereBeforeToday($columns); + } + + /** + * Add a "where date" clause to determine if a "date" column is today or before to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereTodayOrBefore($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereTodayOrBefore($columns); + } + + /** + * Add a "where date" clause to determine if a "date" column is after today. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereAfterToday($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereAfterToday($columns); + } + + /** + * Add a "where date" clause to determine if a "date" column is today or after to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function whereTodayOrAfter($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->whereTodayOrAfter($columns); + } + + /** + * Add an "or where date" clause to determine if a "date" column is today to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereToday($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereToday($columns); + } + + /** + * Add an "or where date" clause to determine if a "date" column is before today. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereBeforeToday($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereBeforeToday($columns); + } + + /** + * Add an "or where date" clause to determine if a "date" column is today or before to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereTodayOrBefore($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereTodayOrBefore($columns); + } + + /** + * Add an "or where date" clause to determine if a "date" column is after today. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereAfterToday($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereAfterToday($columns); + } + + /** + * Add an "or where date" clause to determine if a "date" column is today or after to the query. + * + * @param array|string $columns + * @return \Illuminate\Database\Eloquent\Builder + * @static + */ + public static function orWhereTodayOrAfter($columns) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->orWhereTodayOrAfter($columns); + } + + /** + * Explains the query. + * + * @return \Illuminate\Support\Collection + * @static + */ + public static function explain() + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->explain(); + } + + /** + * Register a custom macro. + * + * @param string $name + * @param object|callable $macro + * @param-closure-this static $macro + * @return void + * @static + */ + public static function macro($name, $macro) + { + \Illuminate\Database\Query\Builder::macro($name, $macro); + } + + /** + * Mix another object into the class. + * + * @param object $mixin + * @param bool $replace + * @return void + * @throws \ReflectionException + * @static + */ + public static function mixin($mixin, $replace = true) + { + \Illuminate\Database\Query\Builder::mixin($mixin, $replace); + } + + /** + * Flush the existing macros. + * + * @return void + * @static + */ + public static function flushMacros() + { + \Illuminate\Database\Query\Builder::flushMacros(); + } + + /** + * Dynamically handle calls to the class. + * + * @param string $method + * @param array $parameters + * @return mixed + * @throws \BadMethodCallException + * @static + */ + public static function macroCall($method, $parameters) + { + /** @var \Illuminate\Database\Query\Builder $instance */ + return $instance->macroCall($method, $parameters); + } + +} +} + + + + + diff --git a/_ide_helper_models.php b/_ide_helper_models.php index ee297d4..28a9627 100644 --- a/_ide_helper_models.php +++ b/_ide_helper_models.php @@ -117,9 +117,9 @@ class IdeHelperLinkedAccount {} * @property int $show_qrcode * @property int|null $downvotes_per_hour * @property int $weighted + * @property string|null $history_playlist_id * @property int $trustscore * @property int|null $trusted_user_id - * @property int $queue * @property int $force * @property int $explicit * @property int $allow_requests @@ -130,7 +130,6 @@ class IdeHelperLinkedAccount {} * @property string|null $device_id * @property string|null $recent_device_id * @property string|null $device_name - * @property string|null $playlist_id * @property string|null $backup_playlist_id * @property string|null $backup_playlist_name * @property \Illuminate\Support\Carbon|null $last_updated_at @@ -160,15 +159,14 @@ class IdeHelperLinkedAccount {} * @method static \Illuminate\Database\Eloquent\Builder|Party whereDownvotesPerHour($value) * @method static \Illuminate\Database\Eloquent\Builder|Party whereExplicit($value) * @method static \Illuminate\Database\Eloquent\Builder|Party whereForce($value) + * @method static \Illuminate\Database\Eloquent\Builder|Party whereHistoryPlaylistId($value) * @method static \Illuminate\Database\Eloquent\Builder|Party whereId($value) * @method static \Illuminate\Database\Eloquent\Builder|Party whereLastUpdatedAt($value) * @method static \Illuminate\Database\Eloquent\Builder|Party whereMaxSongLength($value) * @method static \Illuminate\Database\Eloquent\Builder|Party whereMinSongLength($value) * @method static \Illuminate\Database\Eloquent\Builder|Party whereName($value) * @method static \Illuminate\Database\Eloquent\Builder|Party whereNoRepeatInterval($value) - * @method static \Illuminate\Database\Eloquent\Builder|Party wherePlaylistId($value) * @method static \Illuminate\Database\Eloquent\Builder|Party wherePoll($value) - * @method static \Illuminate\Database\Eloquent\Builder|Party whereQueue($value) * @method static \Illuminate\Database\Eloquent\Builder|Party whereRecentDeviceId($value) * @method static \Illuminate\Database\Eloquent\Builder|Party whereShowQrcode($value) * @method static \Illuminate\Database\Eloquent\Builder|Party whereSongId($value) diff --git a/app/Http/Controllers/PartyController.php b/app/Http/Controllers/PartyController.php index 02324a6..ebd28c6 100644 --- a/app/Http/Controllers/PartyController.php +++ b/app/Http/Controllers/PartyController.php @@ -161,6 +161,11 @@ protected function updateObject(Party $party, Request $request): void if ($request->has('no_repeat_interval') && $request->input('no_repeat_interval') > 0) { $party->no_repeat_interval = $request->input('no_repeat_interval'); } + if ($request->has('history_playlist_id') && $request->input('history_playlist_id') !== 'none') { + $party->history_playlist_id = $request->input('history_playlist_id'); + } else { + $party->history_playlist_id = null; + } $party->save(); } } diff --git a/app/Http/Controllers/UserController.php b/app/Http/Controllers/UserController.php index 32af2d1..c993ae9 100644 --- a/app/Http/Controllers/UserController.php +++ b/app/Http/Controllers/UserController.php @@ -47,6 +47,9 @@ public function login_redirect(SocialProvider $socialprovider) public function login_return(SocialProvider $socialprovider) { + if (Auth::hasUser()) { + return response()->redirectToIntended(route('home'))->with('successMessage', 'You have been logged in'); + } if (!$socialprovider->enabled || !$socialprovider->auth_enabled) { return response()->redirectToRoute('login')->with('errorMessage', 'Unable to login'); } diff --git a/app/Http/Requests/PartyRequest.php b/app/Http/Requests/PartyRequest.php index d26e3a1..ece5396 100644 --- a/app/Http/Requests/PartyRequest.php +++ b/app/Http/Requests/PartyRequest.php @@ -34,7 +34,6 @@ public function rules(): array 'required', 'string', 'in:other,' . collect($playlists)->pluck('id')->implode(','), - ], 'custom_backup_playlist_id' => 'required_if:backup_playlist_id,other|string|nullable', 'allow_requests' => 'sometimes|boolean', @@ -53,7 +52,13 @@ public function rules(): array ], 'min_song_length' => 'sometimes|integer|min:1|nullable', 'max_song_length' => 'sometimes|integer|min:1|nullable', - 'no_repeat_interval' => 'sometimes|integer|min:1|nullable' + 'no_repeat_interval' => 'sometimes|integer|min:1|nullable', + 'history_playlist_id' => [ + 'sometimes', + 'string', + 'in:other,' . collect($playlists)->pluck('id')->push('none')->implode(','), + 'nullable', + ], ]; } } diff --git a/app/Models/Party.php b/app/Models/Party.php index 871e900..564c442 100644 --- a/app/Models/Party.php +++ b/app/Models/Party.php @@ -217,6 +217,20 @@ public function play(?string $playbackDevice): void if (is_object($current) && property_exists($current, 'item') && $current->item->id !== null && $current->item->type === 'track') { $trackUri = "spotify:track:{$current->item->id}"; } + if ($trackUri === '') { + $song = $this->history()->orderBy('played_at', 'desc')->first(); + if ($song) { + $trackUri = "spotify:track:{$song->song->spotify_id}"; + } + } + if ($trackUri === '') { + // We are stuck, let's add something to the queue and use it + $this->addTracksToQueue(); + $song = $this->upcoming()->orderBy('queued_at', 'desc')->first(); + if ($song) { + $trackUri = "spotify:track:{$song->song->spotify_id}"; + } + } $this->user->getSpotifyApi()->play($playbackDevice, [ 'uris' => [$trackUri], ]); @@ -353,6 +367,11 @@ protected function addTracksToQueue(): void $this->user->getSpotifyApi()->queue($song->song->spotify_id); $song->queued_at = Carbon::now(); $song->save(); + if ($this->history_playlist_id !== null) { + Log::info("{$this}: Adding {$song->song} to history playlist"); + Log::debug("{$this}: Spotify API -> addPlaylistTracks({$this->history_playlist_id}, [{$song->song->spotify_id}])"); + $this->user->getSpotifyApi()->addPlaylistTracks($this->history_playlist_id, [$song->song->spotify_id]); + } } } diff --git a/collector.yml b/collector.yml index 54c77d3..1236412 100644 --- a/collector.yml +++ b/collector.yml @@ -8,11 +8,15 @@ receivers: prometheus: config: scrape_configs: - - job_name: 'otel-collector' + - job_name: 'musicparty' scrape_interval: 30s metrics_path: '/prometheus' static_configs: - targets: [ 'musicparty:80' ] + - job_name: 'frankenphp' + scrape_interval: 15s + static_configs: + - targets: [ 'musicparty:2019' ] processors: batch: diff --git a/composer.json b/composer.json index 95a6bd2..40b4474 100644 --- a/composer.json +++ b/composer.json @@ -20,6 +20,7 @@ "numphp/numphp": "^1.2", "open-telemetry/exporter-otlp": "^1.3", "open-telemetry/gen-otlp-protobuf": "^1.5", + "open-telemetry/opentelemetry-auto-laravel": "^1.2", "open-telemetry/sdk": "^1.6", "open-telemetry/transport-grpc": "^1.1", "pusher/pusher-php-server": "^7.2", diff --git a/composer.lock b/composer.lock index 1d9efb9..5f8f235 100644 --- a/composer.lock +++ b/composer.lock @@ -4,7 +4,7 @@ "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies", "This file is @generated automatically" ], - "content-hash": "1a6b9ec75467fc9d71809ff0a97389cf", + "content-hash": "760e079a3c471c49618d120e8dc84181", "packages": [ { "name": "brick/math", @@ -1659,16 +1659,16 @@ }, { "name": "laravel/framework", - "version": "v12.19.3", + "version": "v12.20.0", "source": { "type": "git", "url": "https://github.com/laravel/framework.git", - "reference": "4e6ec689ef704bb4bd282f29d9dd658dfb4fb262" + "reference": "1b9a00f8caf5503c92aa436279172beae1a484ff" }, "dist": { "type": "zip", - "url": "https://api.github.com/repos/laravel/framework/zipball/4e6ec689ef704bb4bd282f29d9dd658dfb4fb262", - "reference": "4e6ec689ef704bb4bd282f29d9dd658dfb4fb262", + "url": "https://api.github.com/repos/laravel/framework/zipball/1b9a00f8caf5503c92aa436279172beae1a484ff", + "reference": "1b9a00f8caf5503c92aa436279172beae1a484ff", "shasum": "" }, "require": { @@ -1870,7 +1870,7 @@ "issues": "https://github.com/laravel/framework/issues", "source": "https://github.com/laravel/framework" }, - "time": "2025-06-18T12:56:23+00:00" + "time": "2025-07-08T15:02:21+00:00" }, { "name": "laravel/horizon", @@ -1954,16 +1954,16 @@ }, { "name": "laravel/octane", - "version": "v2.10.0", + "version": "v2.11.0", "source": { "type": "git", "url": "https://github.com/laravel/octane.git", - "reference": "62bf04dcb471e7d91c8aeda9b4e7376a75000ee5" + "reference": "00e4d40047a24c267c9d3d0abfb47a6e27a7dc7f" }, "dist": { "type": "zip", - "url": "https://api.github.com/repos/laravel/octane/zipball/62bf04dcb471e7d91c8aeda9b4e7376a75000ee5", - "reference": "62bf04dcb471e7d91c8aeda9b4e7376a75000ee5", + "url": "https://api.github.com/repos/laravel/octane/zipball/00e4d40047a24c267c9d3d0abfb47a6e27a7dc7f", + "reference": "00e4d40047a24c267c9d3d0abfb47a6e27a7dc7f", "shasum": "" }, "require": { @@ -2040,20 +2040,20 @@ "issues": "https://github.com/laravel/octane/issues", "source": "https://github.com/laravel/octane" }, - "time": "2025-06-16T13:44:31+00:00" + "time": "2025-06-28T17:28:13+00:00" }, { "name": "laravel/prompts", - "version": "v0.3.5", + "version": "v0.3.6", "source": { "type": "git", "url": "https://github.com/laravel/prompts.git", - "reference": "57b8f7efe40333cdb925700891c7d7465325d3b1" + "reference": "86a8b692e8661d0fb308cec64f3d176821323077" }, "dist": { "type": "zip", - "url": "https://api.github.com/repos/laravel/prompts/zipball/57b8f7efe40333cdb925700891c7d7465325d3b1", - "reference": "57b8f7efe40333cdb925700891c7d7465325d3b1", + "url": "https://api.github.com/repos/laravel/prompts/zipball/86a8b692e8661d0fb308cec64f3d176821323077", + "reference": "86a8b692e8661d0fb308cec64f3d176821323077", "shasum": "" }, "require": { @@ -2097,9 +2097,9 @@ "description": "Add beautiful and user-friendly forms to your command-line applications.", "support": { "issues": "https://github.com/laravel/prompts/issues", - "source": "https://github.com/laravel/prompts/tree/v0.3.5" + "source": "https://github.com/laravel/prompts/tree/v0.3.6" }, - "time": "2025-02-11T13:34:40+00:00" + "time": "2025-07-07T14:17:42+00:00" }, { "name": "laravel/pulse", @@ -2272,16 +2272,16 @@ }, { "name": "laravel/sanctum", - "version": "v4.1.1", + "version": "v4.1.2", "source": { "type": "git", "url": "https://github.com/laravel/sanctum.git", - "reference": "a360a6a1fd2400ead4eb9b6a9c1bb272939194f5" + "reference": "e4c09e69aecd5a383e0c1b85a6bb501c997d7491" }, "dist": { "type": "zip", - "url": "https://api.github.com/repos/laravel/sanctum/zipball/a360a6a1fd2400ead4eb9b6a9c1bb272939194f5", - "reference": "a360a6a1fd2400ead4eb9b6a9c1bb272939194f5", + "url": "https://api.github.com/repos/laravel/sanctum/zipball/e4c09e69aecd5a383e0c1b85a6bb501c997d7491", + "reference": "e4c09e69aecd5a383e0c1b85a6bb501c997d7491", "shasum": "" }, "require": { @@ -2332,7 +2332,7 @@ "issues": "https://github.com/laravel/sanctum/issues", "source": "https://github.com/laravel/sanctum" }, - "time": "2025-04-23T13:03:38+00:00" + "time": "2025-07-01T15:49:32+00:00" }, { "name": "laravel/serializable-closure", @@ -2469,16 +2469,16 @@ }, { "name": "laravel/telescope", - "version": "v5.9.1", + "version": "v5.10.0", "source": { "type": "git", "url": "https://github.com/laravel/telescope.git", - "reference": "403d4ad1ecfe126139f5cf29cabd6b1c816c46a2" + "reference": "fc0a8662682c0375b534033873debb780c003486" }, "dist": { "type": "zip", - "url": "https://api.github.com/repos/laravel/telescope/zipball/403d4ad1ecfe126139f5cf29cabd6b1c816c46a2", - "reference": "403d4ad1ecfe126139f5cf29cabd6b1c816c46a2", + "url": "https://api.github.com/repos/laravel/telescope/zipball/fc0a8662682c0375b534033873debb780c003486", + "reference": "fc0a8662682c0375b534033873debb780c003486", "shasum": "" }, "require": { @@ -2532,9 +2532,9 @@ ], "support": { "issues": "https://github.com/laravel/telescope/issues", - "source": "https://github.com/laravel/telescope/tree/v5.9.1" + "source": "https://github.com/laravel/telescope/tree/v5.10.0" }, - "time": "2025-06-10T21:42:27+00:00" + "time": "2025-07-07T14:47:19+00:00" }, { "name": "laravel/tinker", @@ -4253,6 +4253,71 @@ }, "time": "2025-01-15T23:07:07+00:00" }, + { + "name": "open-telemetry/opentelemetry-auto-laravel", + "version": "1.2.2", + "source": { + "type": "git", + "url": "https://github.com/opentelemetry-php/contrib-auto-laravel.git", + "reference": "be321c5ffc6a4db5879d77d20cb0562bb8a869a1" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/opentelemetry-php/contrib-auto-laravel/zipball/be321c5ffc6a4db5879d77d20cb0562bb8a869a1", + "reference": "be321c5ffc6a4db5879d77d20cb0562bb8a869a1", + "shasum": "" + }, + "require": { + "ext-json": "*", + "ext-opentelemetry": "*", + "laravel/framework": "^6.0 || ^7.0 || ^8.0 || ^9.0 || ^10.0 || ^11.0 || ^12.0", + "open-telemetry/api": "^1.0", + "open-telemetry/sem-conv": "^1.32", + "php": "^8.1" + }, + "require-dev": { + "friendsofphp/php-cs-fixer": "^3.50", + "guzzlehttp/guzzle": "*", + "nunomaduro/collision": "*", + "open-telemetry/sdk": "^1.0", + "orchestra/testbench": ">=7.41.3", + "phan/phan": "^5.0", + "php-http/mock-client": "*", + "phpstan/phpstan": "^1.1", + "phpstan/phpstan-phpunit": "^1.0", + "phpunit/phpunit": "^9.5", + "psalm/plugin-phpunit": "^0.19.2", + "spatie/laravel-ignition": "*", + "vimeo/psalm": "6.4.0" + }, + "type": "library", + "autoload": { + "files": [ + "_register.php" + ], + "psr-4": { + "OpenTelemetry\\Contrib\\Instrumentation\\Laravel\\": "src/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "Apache-2.0" + ], + "description": "OpenTelemetry auto-instrumentation for Laravel", + "homepage": "https://opentelemetry.io/docs/php", + "keywords": [ + "instrumentation", + "laravel", + "open-telemetry", + "opentelemetry", + "otel", + "tracing" + ], + "support": { + "source": "https://github.com/opentelemetry-php/contrib-auto-laravel/tree/1.2.2" + }, + "time": "2025-06-17T23:42:05+00:00" + }, { "name": "open-telemetry/sdk", "version": "1.6.0", @@ -10567,16 +10632,16 @@ }, { "name": "laravel/pint", - "version": "v1.23.0", + "version": "v1.24.0", "source": { "type": "git", "url": "https://github.com/laravel/pint.git", - "reference": "9ab851dba4faa51a3c3223dd3d07044129021024" + "reference": "0345f3b05f136801af8c339f9d16ef29e6b4df8a" }, "dist": { "type": "zip", - "url": "https://api.github.com/repos/laravel/pint/zipball/9ab851dba4faa51a3c3223dd3d07044129021024", - "reference": "9ab851dba4faa51a3c3223dd3d07044129021024", + "url": "https://api.github.com/repos/laravel/pint/zipball/0345f3b05f136801af8c339f9d16ef29e6b4df8a", + "reference": "0345f3b05f136801af8c339f9d16ef29e6b4df8a", "shasum": "" }, "require": { @@ -10587,7 +10652,7 @@ "php": "^8.2.0" }, "require-dev": { - "friendsofphp/php-cs-fixer": "^3.76.0", + "friendsofphp/php-cs-fixer": "^3.82.2", "illuminate/view": "^11.45.1", "larastan/larastan": "^3.5.0", "laravel-zero/framework": "^11.45.0", @@ -10632,7 +10697,7 @@ "issues": "https://github.com/laravel/pint/issues", "source": "https://github.com/laravel/pint" }, - "time": "2025-07-03T10:37:47+00:00" + "time": "2025-07-10T18:09:32+00:00" }, { "name": "laravel/sail", @@ -10782,16 +10847,16 @@ }, { "name": "myclabs/deep-copy", - "version": "1.13.2", + "version": "1.13.3", "source": { "type": "git", "url": "https://github.com/myclabs/DeepCopy.git", - "reference": "d25e62e636b0a9b01e3bdebb7823b474876dd829" + "reference": "faed855a7b5f4d4637717c2b3863e277116beb36" }, "dist": { "type": "zip", - "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/d25e62e636b0a9b01e3bdebb7823b474876dd829", - "reference": "d25e62e636b0a9b01e3bdebb7823b474876dd829", + "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/faed855a7b5f4d4637717c2b3863e277116beb36", + "reference": "faed855a7b5f4d4637717c2b3863e277116beb36", "shasum": "" }, "require": { @@ -10830,7 +10895,7 @@ ], "support": { "issues": "https://github.com/myclabs/DeepCopy/issues", - "source": "https://github.com/myclabs/DeepCopy/tree/1.13.2" + "source": "https://github.com/myclabs/DeepCopy/tree/1.13.3" }, "funding": [ { @@ -10838,7 +10903,7 @@ "type": "tidelift" } ], - "time": "2025-07-04T14:07:32+00:00" + "time": "2025-07-05T12:25:42+00:00" }, { "name": "nunomaduro/collision", @@ -11628,16 +11693,16 @@ }, { "name": "phpstan/phpdoc-parser", - "version": "2.1.0", + "version": "2.2.0", "source": { "type": "git", "url": "https://github.com/phpstan/phpdoc-parser.git", - "reference": "9b30d6fd026b2c132b3985ce6b23bec09ab3aa68" + "reference": "b9e61a61e39e02dd90944e9115241c7f7e76bfd8" }, "dist": { "type": "zip", - "url": "https://api.github.com/repos/phpstan/phpdoc-parser/zipball/9b30d6fd026b2c132b3985ce6b23bec09ab3aa68", - "reference": "9b30d6fd026b2c132b3985ce6b23bec09ab3aa68", + "url": "https://api.github.com/repos/phpstan/phpdoc-parser/zipball/b9e61a61e39e02dd90944e9115241c7f7e76bfd8", + "reference": "b9e61a61e39e02dd90944e9115241c7f7e76bfd8", "shasum": "" }, "require": { @@ -11669,9 +11734,9 @@ "description": "PHPDoc parser with support for nullable, intersection and generic types", "support": { "issues": "https://github.com/phpstan/phpdoc-parser/issues", - "source": "https://github.com/phpstan/phpdoc-parser/tree/2.1.0" + "source": "https://github.com/phpstan/phpdoc-parser/tree/2.2.0" }, - "time": "2025-02-19T13:28:12+00:00" + "time": "2025-07-13T07:04:09+00:00" }, { "name": "phpunit/php-code-coverage", diff --git a/database/migrations/2025_07_20_085108_add_history_playlist_id_to_parties.php b/database/migrations/2025_07_20_085108_add_history_playlist_id_to_parties.php new file mode 100644 index 0000000..12584c5 --- /dev/null +++ b/database/migrations/2025_07_20_085108_add_history_playlist_id_to_parties.php @@ -0,0 +1,28 @@ +string('history_playlist_id')->nullable()->default(null)->after('weighted'); + }); + } + + /** + * Reverse the migrations. + */ + public function down(): void + { + Schema::table('parties', function (Blueprint $table) { + $table->dropColumn('history_playlist_id'); + }); + } +}; diff --git a/docker-compose.yaml b/docker-compose.yaml index 0951287..b2ee4eb 100644 --- a/docker-compose.yaml +++ b/docker-compose.yaml @@ -8,6 +8,7 @@ services: restart: unless-stopped volumes: - ./:/app + env_file: .env environment: - XDEBUG_CONFIG=client_host=host.docker.internal - PHP_IDE_CONFIG=serverName=musicparty diff --git a/docker/develop/Dockerfile b/docker/develop/Dockerfile index 5072180..ba211f9 100644 --- a/docker/develop/Dockerfile +++ b/docker/develop/Dockerfile @@ -3,7 +3,7 @@ FROM ghcr.io/mintopia/php-frankenphp-base:8.4.10 RUN apk add --update nodejs npm && \ npm install -g chokidar && \ install-php-extensions xdebug && \ - echo 'memory_limit = 256M' > /usr/local/etc/php/conf.d/memory_limit.ini + echo 'memory_limit = 512M' > /usr/local/etc/php/conf.d/memory_limit.ini COPY --from=composer:latest /usr/bin/composer /usr/local/bin/ diff --git a/docker/production/Dockerfile b/docker/production/Dockerfile index 14950d8..14aa51e 100644 --- a/docker/production/Dockerfile +++ b/docker/production/Dockerfile @@ -33,7 +33,8 @@ LABEL org.opencontainers.image.authors="jess@mintopia.net" COPY --from=npm /app /app COPY docker/production/entrypoint.sh /entrypoint.sh RUN chmod +x /entrypoint.sh && \ - mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini" + mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini" && \ + echo 'memory_limit = 512M' > /usr/local/etc/php/conf.d/memory_limit.ini COPY docker/Caddyfile / diff --git a/docker/production/production.env b/docker/production/production.env index 7e737f0..a7bcf1c 100644 --- a/docker/production/production.env +++ b/docker/production/production.env @@ -35,6 +35,7 @@ VITE_REVERB_PORT=443 VITE_REVERB_SCHEME="https" OCTANE_SERVER=frankenphp -OTEL_PHP_AUTOLOAD_ENABLED=false +OTEL_PHP_AUTOLOAD_ENABLED=false OTEL_PHP_EXCLUDED_URLS="pulse,telescope/.*,horizon/.*,api/v1/ping,_ignition/.*,_debugbar/.*" +OTEL_EXPORTER_OTLP_PROTOCOL=grpc diff --git a/resources/views/parties/_form.blade.php b/resources/views/parties/_form.blade.php index c23ac59..04469d0 100644 --- a/resources/views/parties/_form.blade.php +++ b/resources/views/parties/_form.blade.php @@ -167,6 +167,24 @@ class=" @enderror +
+ +
+ + If you set a history playlist, anything added to the queue will be added to this playlist. + @error('backup_playlist_id') +

{{ $message }}

+ @enderror +
+