-
-| Event Name |
-|----------------------------------------------|
-| `Hypervel\Cache\Events\CacheFlushed` |
-| `Hypervel\Cache\Events\CacheFlushing` |
-| `Hypervel\Cache\Events\CacheHit` |
-| `Hypervel\Cache\Events\CacheMissed` |
-| `Hypervel\Cache\Events\ForgettingKey` |
-| `Hypervel\Cache\Events\KeyForgetFailed` |
-| `Hypervel\Cache\Events\KeyForgotten` |
-| `Hypervel\Cache\Events\KeyWriteFailed` |
-| `Hypervel\Cache\Events\KeyWritten` |
-| `Hypervel\Cache\Events\RetrievingKey` |
-| `Hypervel\Cache\Events\RetrievingManyKeys` |
-| `Hypervel\Cache\Events\WritingKey` |
-| `Hypervel\Cache\Events\WritingManyKeys` |
-
-
-
-To increase performance, cache events are disabled in Hypervel by default. You may enable cache events by setting the `events` configuration option to `true` for a given cache store in your application's `config/cache.php` configuration file:
-
-```php
-'database' => [
- 'driver' => 'database',
- // ...
- 'events' => true,
-],
-```
diff --git a/_archive/docs/0.3/docs/collections.md b/_archive/docs/0.3/docs/collections.md
deleted file mode 100644
index 7d073a65c2..0000000000
--- a/_archive/docs/0.3/docs/collections.md
+++ /dev/null
@@ -1,4084 +0,0 @@
-# Collections
-[[toc]]
-
-## Introduction
-
-The `Hypervel\Support\Collection` class provides a fluent, convenient wrapper for working with arrays of data. For example, check out the following code. We'll use the `collect` helper to create a new collection instance from the array, run the `strtoupper` function on each element, and then remove all empty elements:
-
-```php
-$collection = collect(['taylor', 'abigail', null])->map(function (?string $name) {
- return strtoupper($name);
-})->reject(function (string $name) {
- return empty($name);
-});
-```
-
-As you can see, the `Collection` class allows you to chain its methods to perform fluent mapping and reducing of the underlying array. In general, collections are immutable, meaning every `Collection` method returns an entirely new `Collection` instance.
-
-### Creating Collections
-
-As mentioned above, the `collect` helper returns a new `Hypervel\Support\Collection` instance for the given array. So, creating a collection is as simple as:
-
-```php
-$collection = collect([1, 2, 3]);
-```
-
-::: note
-The results of [Eloquent](/docs/eloquent) queries are always returned as `Collection` instances.
-:::
-
-### Extending Collections
-
-Collections are "macroable", which allows you to add additional methods to the `Collection` class at run time. The `Hypervel\Support\Collection` class' `macro` method accepts a closure that will be executed when your macro is called. The macro closure may access the collection's other methods via `$this`, just as if it were a real method of the collection class. For example, the following code adds a `toUpper` method to the `Collection` class:
-
-```php
-use Hypervel\Support\Collection;
-use Hypervel\Support\Str;
-
-Collection::macro('toUpper', function () {
- return $this->map(function (string $value) {
- return Str::upper($value);
- });
-});
-
-$collection = collect(['first', 'second']);
-
-$upper = $collection->toUpper();
-
-// ['FIRST', 'SECOND']
-```
-
-Typically, you should declare collection macros in the `boot` method of a [service provider](/docs/providers).
-
-#### Macro Arguments
-
-If necessary, you may define macros that accept additional arguments:
-
-```php
-use Hypervel\Support\Collection;
-use Hypervel\Support\Facades\Lang;
-
-Collection::macro('toLocale', function (string $locale) {
- return $this->map(function (string $value) use ($locale) {
- return Lang::get($value, [], $locale);
- });
-});
-
-$collection = collect(['first', 'second']);
-
-$translated = $collection->toLocale('es');
-```
-
-## Available Methods
-
-For the majority of the remaining collection documentation, we'll discuss each method available on the `Collection` class. Remember, all of these methods may be chained to fluently manipulate the underlying array. Furthermore, almost every method returns a new `Collection` instance, allowing you to preserve the original copy of the collection when necessary:
-
-
-
-
-
-[all](#method-all)
-[average](#method-average)
-[avg](#method-avg)
-[chunk](#method-chunk)
-[chunkWhile](#method-chunkwhile)
-[collapse](#method-collapse)
-[collect](#method-collect)
-[combine](#method-combine)
-[concat](#method-concat)
-[contains](#method-contains)
-[containsOneItem](#method-containsoneitem)
-[containsStrict](#method-containsstrict)
-[count](#method-count)
-[countBy](#method-countBy)
-[crossJoin](#method-crossjoin)
-[dd](#method-dd)
-[diff](#method-diff)
-[diffAssoc](#method-diffassoc)
-[diffAssocUsing](#method-diffassocusing)
-[diffKeys](#method-diffkeys)
-[doesntContain](#method-doesntcontain)
-[dot](#method-dot)
-[dump](#method-dump)
-[duplicates](#method-duplicates)
-[duplicatesStrict](#method-duplicatesstrict)
-[each](#method-each)
-[eachSpread](#method-eachspread)
-[ensure](#method-ensure)
-[every](#method-every)
-[except](#method-except)
-[filter](#method-filter)
-[first](#method-first)
-[firstOrFail](#method-first-or-fail)
-[firstWhere](#method-first-where)
-[flatMap](#method-flatmap)
-[flatten](#method-flatten)
-[flip](#method-flip)
-[forget](#method-forget)
-[forPage](#method-forpage)
-[get](#method-get)
-[groupBy](#method-groupby)
-[has](#method-has)
-[hasAny](#method-hasany)
-[implode](#method-implode)
-[intersect](#method-intersect)
-[intersectAssoc](#method-intersectAssoc)
-[intersectByKeys](#method-intersectbykeys)
-[isEmpty](#method-isempty)
-[isNotEmpty](#method-isnotempty)
-[join](#method-join)
-[keyBy](#method-keyby)
-[keys](#method-keys)
-[last](#method-last)
-[lazy](#method-lazy)
-[macro](#method-macro)
-[make](#method-make)
-[map](#method-map)
-[mapInto](#method-mapinto)
-[mapSpread](#method-mapspread)
-[mapToGroups](#method-maptogroups)
-[mapWithKeys](#method-mapwithkeys)
-[max](#method-max)
-[median](#method-median)
-[merge](#method-merge)
-[mergeRecursive](#method-mergerecursive)
-[min](#method-min)
-[mode](#method-mode)
-[nth](#method-nth)
-[only](#method-only)
-[pad](#method-pad)
-[partition](#method-partition)
-[percentage](#method-percentage)
-[pipe](#method-pipe)
-[pipeInto](#method-pipeinto)
-[pipeThrough](#method-pipethrough)
-[pluck](#method-pluck)
-[pop](#method-pop)
-[prepend](#method-prepend)
-[pull](#method-pull)
-[push](#method-push)
-[put](#method-put)
-[random](#method-random)
-[range](#method-range)
-[reduce](#method-reduce)
-[reduceSpread](#method-reduce-spread)
-[reject](#method-reject)
-[replace](#method-replace)
-[replaceRecursive](#method-replacerecursive)
-[reverse](#method-reverse)
-[search](#method-search)
-[select](#method-select)
-[shift](#method-shift)
-[shuffle](#method-shuffle)
-[skip](#method-skip)
-[skipUntil](#method-skipuntil)
-[skipWhile](#method-skipwhile)
-[slice](#method-slice)
-[sliding](#method-sliding)
-[sole](#method-sole)
-[some](#method-some)
-[sort](#method-sort)
-[sortBy](#method-sortby)
-[sortByDesc](#method-sortbydesc)
-[sortDesc](#method-sortdesc)
-[sortKeys](#method-sortkeys)
-[sortKeysDesc](#method-sortkeysdesc)
-[sortKeysUsing](#method-sortkeysusing)
-[splice](#method-splice)
-[split](#method-split)
-[splitIn](#method-splitin)
-[sum](#method-sum)
-[take](#method-take)
-[takeUntil](#method-takeuntil)
-[takeWhile](#method-takewhile)
-[tap](#method-tap)
-[times](#method-times)
-[toArray](#method-toarray)
-[toJson](#method-tojson)
-[transform](#method-transform)
-[undot](#method-undot)
-[union](#method-union)
-[unique](#method-unique)
-[uniqueStrict](#method-uniquestrict)
-[unless](#method-unless)
-[unlessEmpty](#method-unlessempty)
-[unlessNotEmpty](#method-unlessnotempty)
-[unwrap](#method-unwrap)
-[value](#method-value)
-[values](#method-values)
-[when](#method-when)
-[whenEmpty](#method-whenempty)
-[whenNotEmpty](#method-whennotempty)
-[where](#method-where)
-[whereStrict](#method-wherestrict)
-[whereBetween](#method-wherebetween)
-[whereIn](#method-wherein)
-[whereInStrict](#method-whereinstrict)
-[whereInstanceOf](#method-whereinstanceof)
-[whereNotBetween](#method-wherenotbetween)
-[whereNotIn](#method-wherenotin)
-[whereNotInStrict](#method-wherenotinstrict)
-[whereNotNull](#method-wherenotnull)
-[whereNull](#method-wherenull)
-[wrap](#method-wrap)
-[zip](#method-zip)
-
-
-
-## Method Listing
-
-
-#### `all()` {.collection-method .first-collection-method}
-
-The `all` method returns the underlying array represented by the collection:
-
-```php
-collect([1, 2, 3])->all();
-
-// [1, 2, 3]
-```
-
-
-#### `average()`
-
-Alias for the [`avg`](#method-avg) method.
-
-
-#### `avg()`
-
-The `avg` method returns the [average value](https://en.wikipedia.org/wiki/Average) of a given key:
-
-```php
-$average = collect([
- ['foo' => 10],
- ['foo' => 10],
- ['foo' => 20],
- ['foo' => 40]
-])->avg('foo');
-
-// 20
-
-$average = collect([1, 1, 2, 4])->avg();
-
-// 2
-```
-
-
-#### `chunk()`
-
-The `chunk` method breaks the collection into multiple, smaller collections of a given size:
-
-```php
-$collection = collect([1, 2, 3, 4, 5, 6, 7]);
-
-$chunks = $collection->chunk(4);
-
-$chunks->all();
-
-// [[1, 2, 3, 4], [5, 6, 7]]
-```
-
-This method is especially useful in [views](/docs/views) when working with a grid system such as [Bootstrap](https://getbootstrap.com/docs/4.1/layout/grid/). For example, imagine you have a collection of [Eloquent](/docs/eloquent) models you want to display in a grid:
-
-```html
-@foreach ($products->chunk(3) as $chunk)
-
- @foreach ($chunk as $product)
-
-@endforeach
-```
-
-
-#### `chunkWhile()`
-
-The `chunkWhile` method breaks the collection into multiple, smaller collections based on the evaluation of the given callback. The `$chunk` variable passed to the closure may be used to inspect the previous element:
-
-```php
-$collection = collect(str_split('AABBCCCD'));
-
-$chunks = $collection->chunkWhile(function (string $value, int $key, Collection $chunk) {
- return $value === $chunk->last();
-});
-
-$chunks->all();
-
-// [['A', 'A'], ['B', 'B'], ['C', 'C', 'C'], ['D']]
-```
-
-
-#### `collapse()`
-
-The `collapse` method collapses a collection of arrays into a single, flat collection:
-
-```php
-$collection = collect([
- [1, 2, 3],
- [4, 5, 6],
- [7, 8, 9],
-]);
-
-$collapsed = $collection->collapse();
-
-$collapsed->all();
-
-// [1, 2, 3, 4, 5, 6, 7, 8, 9]
-```
-
-#### `collect()`
-
-The `collect` method returns a new `Collection` instance with the items currently in the collection:
-
-```php
-$collectionA = collect([1, 2, 3]);
-
-$collectionB = $collectionA->collect();
-
-$collectionB->all();
-
-// [1, 2, 3]
-```
-
-The `collect` method is primarily useful for converting [lazy collections](#lazy-collections) into standard `Collection` instances:
-
-```php
-$lazyCollection = LazyCollection::make(function () {
- yield 1;
- yield 2;
- yield 3;
-});
-
-$collection = $lazyCollection->collect();
-
-$collection::class;
-
-// 'Hypervel\Support\Collection'
-
-$collection->all();
-
-// [1, 2, 3]
-```
-
-::: note
-The `collect` method is especially useful when you have an instance of `Enumerable` and need a non-lazy collection instance. Since `collect()` is part of the `Enumerable` contract, you can safely use it to get a `Collection` instance.
-:::
-
-
-#### `combine()`
-
-The `combine` method combines the values of the collection, as keys, with the values of another array or collection:
-
-```php
-$collection = collect(['name', 'age']);
-
-$combined = $collection->combine(['George', 29]);
-
-$combined->all();
-
-// ['name' => 'George', 'age' => 29]
-```
-
-
-#### `concat()`
-
-The `concat` method appends the given `array` or collection's values onto the end of another collection:
-
-```php
-$collection = collect(['John Doe']);
-
-$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);
-
-$concatenated->all();
-
-// ['John Doe', 'Jane Doe', 'Johnny Doe']
-```
-
-The `concat` method numerically reindexes keys for items concatenated onto the original collection. To maintain keys in associative collections, see the [merge](#method-merge) method.
-
-
-#### `contains()`
-
-The `contains` method determines whether the collection contains a given item. You may pass a closure to the `contains` method to determine if an element exists in the collection matching a given truth test:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$collection->contains(function (int $value, int $key) {
- return $value > 5;
-});
-
-// false
-```
-
-Alternatively, you may pass a string to the `contains` method to determine whether the collection contains a given item value:
-
-```php
-$collection = collect(['name' => 'Desk', 'price' => 100]);
-
-$collection->contains('Desk');
-
-// true
-
-$collection->contains('New York');
-
-// false
-```
-
-You may also pass a key / value pair to the `contains` method, which will determine if the given pair exists in the collection:
-
-```php
-$collection = collect([
- ['product' => 'Desk', 'price' => 200],
- ['product' => 'Chair', 'price' => 100],
-]);
-
-$collection->contains('product', 'Bookcase');
-
-// false
-```
-
-The `contains` method uses "loose" comparisons when checking item values, meaning a string with an integer value will be considered equal to an integer of the same value. Use the [`containsStrict`](#method-containsstrict) method to filter using "strict" comparisons.
-
-For the inverse of `contains`, see the [doesntContain](#method-doesntcontain) method.
-
-
-#### `containsOneItem()`
-
-The `containsOneItem` method determines whether the collection contains a single item:
-
-```php
-collect([])->containsOneItem();
-
-// false
-
-collect(['1'])->containsOneItem();
-
-// true
-
-collect(['1', '2'])->containsOneItem();
-
-// false
-```
-
-
-#### `containsStrict()`
-
-This method has the same signature as the [`contains`](#method-contains) method; however, all values are compared using "strict" comparisons.
-
-::: note
-This method's behavior is modified when using [Eloquent Collections](/docs/eloquent-collections#method-contains).
-:::
-
-
-#### `count()`
-
-The `count` method returns the total number of items in the collection:
-
-```php
-$collection = collect([1, 2, 3, 4]);
-
-$collection->count();
-
-// 4
-```
-
-
-#### `countBy()`
-
-The `countBy` method counts the occurrences of values in the collection. By default, the method counts the occurrences of every element, allowing you to count certain "types" of elements in the collection:
-
-```php
-$collection = collect([1, 2, 2, 2, 3]);
-
-$counted = $collection->countBy();
-
-$counted->all();
-
-// [1 => 1, 2 => 3, 3 => 1]
-```
-
-You pass a closure to the `countBy` method to count all items by a custom value:
-
-```php
-$collection = collect(['alice@gmail.com', 'bob@yahoo.com', 'carlos@gmail.com']);
-
-$counted = $collection->countBy(function (string $email) {
- return substr(strrchr($email, "@"), 1);
-});
-
-$counted->all();
-
-// ['gmail.com' => 2, 'yahoo.com' => 1]
-```
-
-
-#### `crossJoin()`
-
-The `crossJoin` method cross joins the collection's values among the given arrays or collections, returning a Cartesian product with all possible permutations:
-
-```php
-$collection = collect([1, 2]);
-
-$matrix = $collection->crossJoin(['a', 'b']);
-
-$matrix->all();
-
-/*
- [
- [1, 'a'],
- [1, 'b'],
- [2, 'a'],
- [2, 'b'],
- ]
-*/
-
-$collection = collect([1, 2]);
-
-$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']);
-
-$matrix->all();
-
-/*
- [
- [1, 'a', 'I'],
- [1, 'a', 'II'],
- [1, 'b', 'I'],
- [1, 'b', 'II'],
- [2, 'a', 'I'],
- [2, 'a', 'II'],
- [2, 'b', 'I'],
- [2, 'b', 'II'],
- ]
-*/
-```
-
-
-#### `dd()`
-
-The `dd` method dumps the collection's items and ends execution of the script:
-
-```php
-$collection = collect(['John Doe', 'Jane Doe']);
-
-$collection->dd();
-
-/*
- Collection {
- #items: array:2 [
- 0 => "John Doe"
- 1 => "Jane Doe"
- ]
- }
-*/
-```
-
-If you do not want to stop executing the script, use the [`dump`](#method-dump) method instead.
-
-
-#### `diff()`
-
-The `diff` method compares the collection against another collection or a plain PHP `array` based on its values. This method will return the values in the original collection that are not present in the given collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$diff = $collection->diff([2, 4, 6, 8]);
-
-$diff->all();
-
-// [1, 3, 5]
-```
-
-::: note
-This method's behavior is modified when using [Eloquent Collections](/docs/eloquent-collections#method-diff).
-:::
-
-
-#### `diffAssoc()`
-
-The `diffAssoc` method compares the collection against another collection or a plain PHP `array` based on its keys and values. This method will return the key / value pairs in the original collection that are not present in the given collection:
-
-```php
-$collection = collect([
- 'color' => 'orange',
- 'type' => 'fruit',
- 'remain' => 6,
-]);
-
-$diff = $collection->diffAssoc([
- 'color' => 'yellow',
- 'type' => 'fruit',
- 'remain' => 3,
- 'used' => 6,
-]);
-
-$diff->all();
-
-// ['color' => 'orange', 'remain' => 6]
-```
-
-
-#### `diffAssocUsing()`
-
-Unlike `diffAssoc`, `diffAssocUsing` accepts a user supplied callback function for the indices comparison:
-
-```php
-$collection = collect([
- 'color' => 'orange',
- 'type' => 'fruit',
- 'remain' => 6,
-]);
-
-$diff = $collection->diffAssocUsing([
- 'Color' => 'yellow',
- 'Type' => 'fruit',
- 'Remain' => 3,
-], 'strnatcasecmp');
-
-$diff->all();
-
-// ['color' => 'orange', 'remain' => 6]
-```
-
-The callback must be a comparison function that returns an integer less than, equal to, or greater than zero. For more information, refer to the PHP documentation on [`array_diff_uassoc`](https://www.php.net/array_diff_uassoc#refsect1-function.array-diff-uassoc-parameters), which is the PHP function that the `diffAssocUsing` method utilizes internally.
-
-
-#### `diffKeys()`
-
-The `diffKeys` method compares the collection against another collection or a plain PHP `array` based on its keys. This method will return the key / value pairs in the original collection that are not present in the given collection:
-
-```php
-$collection = collect([
- 'one' => 10,
- 'two' => 20,
- 'three' => 30,
- 'four' => 40,
- 'five' => 50,
-]);
-
-$diff = $collection->diffKeys([
- 'two' => 2,
- 'four' => 4,
- 'six' => 6,
- 'eight' => 8,
-]);
-
-$diff->all();
-
-// ['one' => 10, 'three' => 30, 'five' => 50]
-```
-
-
-#### `doesntContain()`
-
-The `doesntContain` method determines whether the collection does not contain a given item. You may pass a closure to the `doesntContain` method to determine if an element does not exist in the collection matching a given truth test:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$collection->doesntContain(function (int $value, int $key) {
- return $value < 5;
-});
-
-// false
-```
-
-Alternatively, you may pass a string to the `doesntContain` method to determine whether the collection does not contain a given item value:
-
-```php
-$collection = collect(['name' => 'Desk', 'price' => 100]);
-
-$collection->doesntContain('Table');
-
-// true
-
-$collection->doesntContain('Desk');
-
-// false
-```
-
-You may also pass a key / value pair to the `doesntContain` method, which will determine if the given pair does not exist in the collection:
-
-```php
-$collection = collect([
- ['product' => 'Desk', 'price' => 200],
- ['product' => 'Chair', 'price' => 100],
-]);
-
-$collection->doesntContain('product', 'Bookcase');
-
-// true
-```
-
-The `doesntContain` method uses "loose" comparisons when checking item values, meaning a string with an integer value will be considered equal to an integer of the same value.
-
-
-#### `dot()`
-
-The `dot` method flattens a multi-dimensional collection into a single level collection that uses "dot" notation to indicate depth:
-
-```php
-$collection = collect(['products' => ['desk' => ['price' => 100]]]);
-
-$flattened = $collection->dot();
-
-$flattened->all();
-
-// ['products.desk.price' => 100]
-```
-
-
-#### `dump()`
-
-The `dump` method dumps the collection's items:
-
-```php
-$collection = collect(['John Doe', 'Jane Doe']);
-
-$collection->dump();
-
-/*
- Collection {
- #items: array:2 [
- 0 => "John Doe"
- 1 => "Jane Doe"
- ]
- }
-*/
-```
-
-If you want to stop executing the script after dumping the collection, use the [`dd`](#method-dd) method instead.
-
-
-#### `duplicates()`
-
-The `duplicates` method retrieves and returns duplicate values from the collection:
-
-```php
-$collection = collect(['a', 'b', 'a', 'c', 'b']);
-
-$collection->duplicates();
-
-// [2 => 'a', 4 => 'b']
-```
-
-If the collection contains arrays or objects, you can pass the key of the attributes that you wish to check for duplicate values:
-
-```php
-$employees = collect([
- ['email' => 'abigail@example.com', 'position' => 'Developer'],
- ['email' => 'james@example.com', 'position' => 'Designer'],
- ['email' => 'victoria@example.com', 'position' => 'Developer'],
-]);
-
-$employees->duplicates('position');
-
-// [2 => 'Developer']
-```
-
-
-#### `duplicatesStrict()`
-
-This method has the same signature as the [`duplicates`](#method-duplicates) method; however, all values are compared using "strict" comparisons.
-
-
-#### `each()`
-
-The `each` method iterates over the items in the collection and passes each item to a closure:
-
-```php
-$collection = collect([1, 2, 3, 4]);
-
-$collection->each(function (int $item, int $key) {
- // ...
-});
-```
-
-If you would like to stop iterating through the items, you may return `false` from your closure:
-
-```php
-$collection->each(function (int $item, int $key) {
- if (/* condition */) {
- return false;
- }
-});
-```
-
-
-#### `eachSpread()`
-
-The `eachSpread` method iterates over the collection's items, passing each nested item value into the given callback:
-
-```php
-$collection = collect([['John Doe', 35], ['Jane Doe', 33]]);
-
-$collection->eachSpread(function (string $name, int $age) {
- // ...
-});
-```
-
-You may stop iterating through the items by returning `false` from the callback:
-
-```php
-$collection->eachSpread(function (string $name, int $age) {
- return false;
-});
-```
-
-
-#### `ensure()`
-
-The `ensure` method may be used to verify that all elements of a collection are of a given type or list of types. Otherwise, an `UnexpectedValueException` will be thrown:
-
-```php
-return $collection->ensure(User::class);
-
-return $collection->ensure([User::class, Customer::class]);
-```
-
-Primitive types such as `string`, `int`, `float`, `bool`, and `array` may also be specified:
-
-```php
-return $collection->ensure('int');
-```
-
-::: warning
-The `ensure` method does not guarantee that elements of different types will not be added to the collection at a later time.
-:::
-
-
-#### `every()`
-
-The `every` method may be used to verify that all elements of a collection pass a given truth test:
-
-```php
-collect([1, 2, 3, 4])->every(function (int $value, int $key) {
- return $value > 2;
-});
-
-// false
-```
-
-If the collection is empty, the `every` method will return true:
-
-```php
-$collection = collect([]);
-
-$collection->every(function (int $value, int $key) {
- return $value > 2;
-});
-
-// true
-```
-
-
-#### `except()`
-
-The `except` method returns all items in the collection except for those with the specified keys:
-
-```php
-$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);
-
-$filtered = $collection->except(['price', 'discount']);
-
-$filtered->all();
-
-// ['product_id' => 1]
-```
-
-For the inverse of `except`, see the [only](#method-only) method.
-
-::: note
-This method's behavior is modified when using [Eloquent Collections](/docs/eloquent-collections#method-except).
-:::
-
-
-#### `filter()`
-
-The `filter` method filters the collection using the given callback, keeping only those items that pass a given truth test:
-
-```php
-$collection = collect([1, 2, 3, 4]);
-
-$filtered = $collection->filter(function (int $value, int $key) {
- return $value > 2;
-});
-
-$filtered->all();
-
-// [3, 4]
-```
-
-If no callback is supplied, all entries of the collection that are equivalent to `false` will be removed:
-
-```php
-$collection = collect([1, 2, 3, null, false, '', 0, []]);
-
-$collection->filter()->all();
-
-// [1, 2, 3]
-```
-
-For the inverse of `filter`, see the [reject](#method-reject) method.
-
-
-#### `first()`
-
-The `first` method returns the first element in the collection that passes a given truth test:
-
-```php
-collect([1, 2, 3, 4])->first(function (int $value, int $key) {
- return $value > 2;
-});
-
-// 3
-```
-
-You may also call the `first` method with no arguments to get the first element in the collection. If the collection is empty, `null` is returned:
-
-```php
-collect([1, 2, 3, 4])->first();
-
-// 1
-```
-
-
-#### `firstOrFail()`
-
-The `firstOrFail` method is identical to the `first` method; however, if no result is found, an `Hyperf\Collection\ItemNotFoundException` exception will be thrown:
-
-```php
-collect([1, 2, 3, 4])->firstOrFail(function (int $value, int $key) {
- return $value > 5;
-});
-
-// Throws ItemNotFoundException...
-```
-
-You may also call the `firstOrFail` method with no arguments to get the first element in the collection. If the collection is empty, an `Hyperf\Collection\ItemNotFoundException` exception will be thrown:
-
-```php
-collect([])->firstOrFail();
-
-// Throws ItemNotFoundException...
-```
-
-
-#### `firstWhere()`
-
-The `firstWhere` method returns the first element in the collection with the given key / value pair:
-
-```php
-$collection = collect([
- ['name' => 'Regena', 'age' => null],
- ['name' => 'Linda', 'age' => 14],
- ['name' => 'Diego', 'age' => 23],
- ['name' => 'Linda', 'age' => 84],
-]);
-
-$collection->firstWhere('name', 'Linda');
-
-// ['name' => 'Linda', 'age' => 14]
-```
-
-You may also call the `firstWhere` method with a comparison operator:
-
-```php
-$collection->firstWhere('age', '>=', 18);
-
-// ['name' => 'Diego', 'age' => 23]
-```
-
-Like the [where](#method-where) method, you may pass one argument to the `firstWhere` method. In this scenario, the `firstWhere` method will return the first item where the given item key's value is "truthy":
-
-
-```php
-$collection->firstWhere('age');
-
-// ['name' => 'Linda', 'age' => 14]
-```
-
-
-#### `flatMap()`
-
-The `flatMap` method iterates through the collection and passes each value to the given closure. The closure is free to modify the item and return it, thus forming a new collection of modified items. Then, the array is flattened by one level:
-
-```php
-$collection = collect([
- ['name' => 'Sally'],
- ['school' => 'Arkansas'],
- ['age' => 28]
-]);
-
-$flattened = $collection->flatMap(function (array $values) {
- return array_map('strtoupper', $values);
-});
-
-$flattened->all();
-
-// ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28'];
-```
-
-
-#### `flatten()`
-
-The `flatten` method flattens a multi-dimensional collection into a single dimension:
-
-```php
-$collection = collect([
- 'name' => 'taylor',
- 'languages' => [
- 'php', 'javascript'
- ]
-]);
-
-$flattened = $collection->flatten();
-
-$flattened->all();
-
-// ['taylor', 'php', 'javascript'];
-```
-
-If necessary, you may pass the `flatten` method a "depth" argument:
-
-```php
-$collection = collect([
- 'Apple' => [
- [
- 'name' => 'iPhone 6S',
- 'brand' => 'Apple'
- ],
- ],
- 'Samsung' => [
- [
- 'name' => 'Galaxy S7',
- 'brand' => 'Samsung'
- ],
- ],
-]);
-
-$products = $collection->flatten(1);
-
-$products->values()->all();
-
-/*
- [
- ['name' => 'iPhone 6S', 'brand' => 'Apple'],
- ['name' => 'Galaxy S7', 'brand' => 'Samsung'],
- ]
-*/
-```
-
-In this example, calling `flatten` without providing the depth would have also flattened the nested arrays, resulting in `['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung']`. Providing a depth allows you to specify the number of levels nested arrays will be flattened.
-
-
-#### `flip()`
-
-The `flip` method swaps the collection's keys with their corresponding values:
-
-```php
-$collection = collect(['language' => 'php', 'framework' => 'Hypervel']);
-
-$flipped = $collection->flip();
-
-$flipped->all();
-
-// ['language' => 'php', 'Hypervel' => 'framework']
-```
-
-
-#### `forget()`
-
-The `forget` method removes an item from the collection by its key:
-
-```php
-$collection = collect(['language' => 'php', 'framework' => 'Hypervel']);
-
-$collection->forget('language');
-
-$collection->all();
-
-// ['framework' => 'Hypervel']
-```
-
-::: warning
-Unlike most other collection methods, `forget` does not return a new modified collection; it modifies the collection it is called on.
-:::
-
-
-#### `forPage()`
-
-The `forPage` method returns a new collection containing the items that would be present on a given page number. The method accepts the page number as its first argument and the number of items to show per page as its second argument:
-
-```php
-$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);
-
-$chunk = $collection->forPage(2, 3);
-
-$chunk->all();
-
-// [4, 5, 6]
-```
-
-
-#### `get()`
-
-The `get` method returns the item at a given key. If the key does not exist, `null` is returned:
-
-```php
-$collection = collect(['language' => 'php', 'framework' => 'Hypervel']);
-
-$value = $collection->get('language');
-
-// php
-```
-
-You may optionally pass a default value as the second argument:
-
-```php
-$collection = collect(['language' => 'php', 'framework' => 'Hypervel']);
-
-$value = $collection->get('age', 34);
-
-// 34
-```
-
-You may even pass a callback as the method's default value. The result of the callback will be returned if the specified key does not exist:
-
-```php
- $collection->get('email', function () {
- return 'taylor@example.com';
- });
-
- // taylor@example.com
-```
-
-
-#### `groupBy()`
-
-The `groupBy` method groups the collection's items by a given key:
-
-```php
-$collection = collect([
- ['account_id' => 'account-x10', 'product' => 'Chair'],
- ['account_id' => 'account-x10', 'product' => 'Bookcase'],
- ['account_id' => 'account-x11', 'product' => 'Desk'],
-]);
-
-$grouped = $collection->groupBy('account_id');
-
-$grouped->all();
-
-/*
- [
- 'account-x10' => [
- ['account_id' => 'account-x10', 'product' => 'Chair'],
- ['account_id' => 'account-x10', 'product' => 'Bookcase'],
- ],
- 'account-x11' => [
- ['account_id' => 'account-x11', 'product' => 'Desk'],
- ],
- ]
-*/
-```
-
-Instead of passing a string `key`, you may pass a callback. The callback should return the value you wish to key the group by:
-
-```php
-$grouped = $collection->groupBy(function (array $item, int $key) {
- return substr($item['account_id'], -3);
-});
-
-$grouped->all();
-
-/*
- [
- 'x10' => [
- ['account_id' => 'account-x10', 'product' => 'Chair'],
- ['account_id' => 'account-x10', 'product' => 'Bookcase'],
- ],
- 'x11' => [
- ['account_id' => 'account-x11', 'product' => 'Desk'],
- ],
- ]
-*/
-```
-
-Multiple grouping criteria may be passed as an array. Each array element will be applied to the corresponding level within a multi-dimensional array:
-
-```php
-$data = new Collection([
- 10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
- 20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
- 30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
- 40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
-]);
-
-$result = $data->groupBy(['skill', function (array $item) {
- return $item['roles'];
-}], preserveKeys: true);
-
-/*
-[
- 1 => [
- 'Role_1' => [
- 10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
- 20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
- ],
- 'Role_2' => [
- 20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
- ],
- 'Role_3' => [
- 10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
- ],
- ],
- 2 => [
- 'Role_1' => [
- 30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
- ],
- 'Role_2' => [
- 40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
- ],
- ],
-];
-*/
-```
-
-
-#### `has()`
-
-The `has` method determines if a given key exists in the collection:
-
-```php
-$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);
-
-$collection->has('product');
-
-// true
-
-$collection->has(['product', 'amount']);
-
-// true
-
-$collection->has(['amount', 'price']);
-
-// false
-```
-
-
-#### `hasAny()`
-
-The `hasAny` method determines whether any of the given keys exist in the collection:
-
-```php
-$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);
-
-$collection->hasAny(['product', 'price']);
-
-// true
-
-$collection->hasAny(['name', 'price']);
-
-// false
-```
-
-
-#### `implode()`
-
-The `implode` method joins items in a collection. Its arguments depend on the type of items in the collection. If the collection contains arrays or objects, you should pass the key of the attributes you wish to join, and the "glue" string you wish to place between the values:
-
-```php
-$collection = collect([
- ['account_id' => 1, 'product' => 'Desk'],
- ['account_id' => 2, 'product' => 'Chair'],
-]);
-
-$collection->implode('product', ', ');
-
-// Desk, Chair
-```
-
-If the collection contains simple strings or numeric values, you should pass the "glue" as the only argument to the method:
-
-```php
-collect([1, 2, 3, 4, 5])->implode('-');
-
-// '1-2-3-4-5'
-```
-
-You may pass a closure to the `implode` method if you would like to format the values being imploded:
-
-```php
-$collection->implode(function (array $item, int $key) {
- return strtoupper($item['product']);
-}, ', ');
-
-// DESK, CHAIR
-```
-
-
-#### `intersect()`
-
-The `intersect` method removes any values from the original collection that are not present in the given `array` or collection. The resulting collection will preserve the original collection's keys:
-
-```php
-$collection = collect(['Desk', 'Sofa', 'Chair']);
-
-$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);
-
-$intersect->all();
-
-// [0 => 'Desk', 2 => 'Chair']
-```
-
-::: note
-This method's behavior is modified when using [Eloquent Collections](/docs/eloquent-collections#method-intersect).
-:::
-
-
-#### `intersectAssoc()`
-
-The `intersectAssoc` method compares the original collection against another collection or `array`, returning the key / value pairs that are present in all of the given collections:
-
-```php
-$collection = collect([
- 'color' => 'red',
- 'size' => 'M',
- 'material' => 'cotton'
-]);
-
-$intersect = $collection->intersectAssoc([
- 'color' => 'blue',
- 'size' => 'M',
- 'material' => 'polyester'
-]);
-
-$intersect->all();
-
-// ['size' => 'M']
-```
-
-
-#### `intersectByKeys()`
-
-The `intersectByKeys` method removes any keys and their corresponding values from the original collection that are not present in the given `array` or collection:
-
-```php
-$collection = collect([
- 'serial' => 'UX301', 'type' => 'screen', 'year' => 2009,
-]);
-
-$intersect = $collection->intersectByKeys([
- 'reference' => 'UX404', 'type' => 'tab', 'year' => 2011,
-]);
-
-$intersect->all();
-
-// ['type' => 'screen', 'year' => 2009]
-```
-
-
-#### `isEmpty()`
-
-The `isEmpty` method returns `true` if the collection is empty; otherwise, `false` is returned:
-
-```php
-collect([])->isEmpty();
-
-// true
-```
-
-
-#### `isNotEmpty()`
-
-The `isNotEmpty` method returns `true` if the collection is not empty; otherwise, `false` is returned:
-
-```php
-collect([])->isNotEmpty();
-
-// false
-```
-
-
-#### `join()`
-
-The `join` method joins the collection's values with a string. Using this method's second argument, you may also specify how the final element should be appended to the string:
-
-```php
-collect(['a', 'b', 'c'])->join(', '); // 'a, b, c'
-collect(['a', 'b', 'c'])->join(', ', ', and '); // 'a, b, and c'
-collect(['a', 'b'])->join(', ', ' and '); // 'a and b'
-collect(['a'])->join(', ', ' and '); // 'a'
-collect([])->join(', ', ' and '); // ''
-```
-
-
-#### `keyBy()`
-
-The `keyBy` method keys the collection by the given key. If multiple items have the same key, only the last one will appear in the new collection:
-
-```php
-$collection = collect([
- ['product_id' => 'prod-100', 'name' => 'Desk'],
- ['product_id' => 'prod-200', 'name' => 'Chair'],
-]);
-
-$keyed = $collection->keyBy('product_id');
-
-$keyed->all();
-
-/*
- [
- 'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
- 'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
- ]
-*/
-```
-
-You may also pass a callback to the method. The callback should return the value to key the collection by:
-
-```php
-$keyed = $collection->keyBy(function (array $item, int $key) {
- return strtoupper($item['product_id']);
-});
-
-$keyed->all();
-
-/*
- [
- 'PROD-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
- 'PROD-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
- ]
-*/
-```
-
-
-#### `keys()`
-
-The `keys` method returns all of the collection's keys:
-
-```php
-$collection = collect([
- 'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
- 'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
-]);
-
-$keys = $collection->keys();
-
-$keys->all();
-
-// ['prod-100', 'prod-200']
-```
-
-
-#### `last()`
-
-The `last` method returns the last element in the collection that passes a given truth test:
-
-```php
-collect([1, 2, 3, 4])->last(function (int $value, int $key) {
- return $value < 3;
-});
-
-// 2
-```
-
-You may also call the `last` method with no arguments to get the last element in the collection. If the collection is empty, `null` is returned:
-
-```php
-collect([1, 2, 3, 4])->last();
-
-// 4
-```
-
-
-#### `lazy()`
-
-The `lazy` method returns a new [`LazyCollection`](#lazy-collections) instance from the underlying array of items:
-
-```php
-$lazyCollection = collect([1, 2, 3, 4])->lazy();
-
-$lazyCollection::class;
-
-// Hyperf\Collection\LazyCollection
-
-$lazyCollection->all();
-
-// [1, 2, 3, 4]
-```
-
-This is especially useful when you need to perform transformations on a huge `Collection` that contains many items:
-
-```php
-$count = $hugeCollection
- ->lazy()
- ->where('country', 'FR')
- ->where('balance', '>', '100')
- ->count();
-```
-
-By converting the collection to a `LazyCollection`, we avoid having to allocate a ton of additional memory. Though the original collection still keeps _its_ values in memory, the subsequent filters will not. Therefore, virtually no additional memory will be allocated when filtering the collection's results.
-
-
-#### `macro()`
-
-The static `macro` method allows you to add methods to the `Collection` class at run time. Refer to the documentation on [extending collections](#extending-collections) for more information.
-
-
-#### `make()`
-
-The static `make` method creates a new collection instance. See the [Creating Collections](#creating-collections) section.
-
-
-#### `map()`
-
-The `map` method iterates through the collection and passes each value to the given callback. The callback is free to modify the item and return it, thus forming a new collection of modified items:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$multiplied = $collection->map(function (int $item, int $key) {
- return $item * 2;
-});
-
-$multiplied->all();
-
-// [2, 4, 6, 8, 10]
-```
-
-::: warning
-> Like most other collection methods, `map` returns a new collection instance; it does not modify the collection it is called on. If you want to transform the original collection, use the [`transform`](#method-transform) method.
-:::
-
-
-#### `mapInto()`
-
-The `mapInto()` method iterates over the collection, creating a new instance of the given class by passing the value into the constructor:
-
-```php
-class Currency
-{
- /**
- * Create a new currency instance.
- */
- function __construct(
- public string $code
- ) {}
-}
-
-$collection = collect(['USD', 'EUR', 'GBP']);
-
-$currencies = $collection->mapInto(Currency::class);
-
-$currencies->all();
-
-// [Currency('USD'), Currency('EUR'), Currency('GBP')]
-```
-
-
-#### `mapSpread()`
-
-The `mapSpread` method iterates over the collection's items, passing each nested item value into the given closure. The closure is free to modify the item and return it, thus forming a new collection of modified items:
-
-```php
-$collection = collect([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-
-$chunks = $collection->chunk(2);
-
-$sequence = $chunks->mapSpread(function (int $even, int $odd) {
- return $even + $odd;
-});
-
-$sequence->all();
-
-// [1, 5, 9, 13, 17]
-```
-
-
-#### `mapToGroups()`
-
-The `mapToGroups` method groups the collection's items by the given closure. The closure should return an associative array containing a single key / value pair, thus forming a new collection of grouped values:
-
-```php
-$collection = collect([
- [
- 'name' => 'John Doe',
- 'department' => 'Sales',
- ],
- [
- 'name' => 'Jane Doe',
- 'department' => 'Sales',
- ],
- [
- 'name' => 'Johnny Doe',
- 'department' => 'Marketing',
- ]
-]);
-
-$grouped = $collection->mapToGroups(function (array $item, int $key) {
- return [$item['department'] => $item['name']];
-});
-
-$grouped->all();
-
-/*
- [
- 'Sales' => ['John Doe', 'Jane Doe'],
- 'Marketing' => ['Johnny Doe'],
- ]
-*/
-
-$grouped->get('Sales')->all();
-
-// ['John Doe', 'Jane Doe']
-```
-
-
-#### `mapWithKeys()`
-
-The `mapWithKeys` method iterates through the collection and passes each value to the given callback. The callback should return an associative array containing a single key / value pair:
-
-```php
-$collection = collect([
- [
- 'name' => 'John',
- 'department' => 'Sales',
- 'email' => 'john@example.com',
- ],
- [
- 'name' => 'Jane',
- 'department' => 'Marketing',
- 'email' => 'jane@example.com',
- ]
-]);
-
-$keyed = $collection->mapWithKeys(function (array $item, int $key) {
- return [$item['email'] => $item['name']];
-});
-
-$keyed->all();
-
-/*
- [
- 'john@example.com' => 'John',
- 'jane@example.com' => 'Jane',
- ]
-*/
-```
-
-
-#### `max()`
-
-The `max` method returns the maximum value of a given key:
-
-```php
-$max = collect([
- ['foo' => 10],
- ['foo' => 20]
-])->max('foo');
-
-// 20
-
-$max = collect([1, 2, 3, 4, 5])->max();
-
-// 5
-```
-
-
-#### `median()`
-
-The `median` method returns the [median value](https://en.wikipedia.org/wiki/Median) of a given key:
-
-```php
-$median = collect([
- ['foo' => 10],
- ['foo' => 10],
- ['foo' => 20],
- ['foo' => 40]
-])->median('foo');
-
-// 15
-
-$median = collect([1, 1, 2, 4])->median();
-
-// 1.5
-```
-
-
-#### `merge()`
-
-The `merge` method merges the given array or collection with the original collection. If a string key in the given items matches a string key in the original collection, the given item's value will overwrite the value in the original collection:
-
-```php
-$collection = collect(['product_id' => 1, 'price' => 100]);
-
-$merged = $collection->merge(['price' => 200, 'discount' => false]);
-
-$merged->all();
-
-// ['product_id' => 1, 'price' => 200, 'discount' => false]
-```
-
-If the given item's keys are numeric, the values will be appended to the end of the collection:
-
-```php
-$collection = collect(['Desk', 'Chair']);
-
-$merged = $collection->merge(['Bookcase', 'Door']);
-
-$merged->all();
-
-// ['Desk', 'Chair', 'Bookcase', 'Door']
-```
-
-
-#### `mergeRecursive()`
-
-The `mergeRecursive` method merges the given array or collection recursively with the original collection. If a string key in the given items matches a string key in the original collection, then the values for these keys are merged together into an array, and this is done recursively:
-
-```php
-$collection = collect(['product_id' => 1, 'price' => 100]);
-
-$merged = $collection->mergeRecursive([
- 'product_id' => 2,
- 'price' => 200,
- 'discount' => false
-]);
-
-$merged->all();
-
-// ['product_id' => [1, 2], 'price' => [100, 200], 'discount' => false]
-```
-
-
-#### `min()`
-
-The `min` method returns the minimum value of a given key:
-
-```php
-$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');
-
-// 10
-
-$min = collect([1, 2, 3, 4, 5])->min();
-
-// 1
-```
-
-
-#### `mode()`
-
-The `mode` method returns the [mode value](https://en.wikipedia.org/wiki/Mode_(statistics)) of a given key:
-
-```php
-$mode = collect([
- ['foo' => 10],
- ['foo' => 10],
- ['foo' => 20],
- ['foo' => 40]
-])->mode('foo');
-
-// [10]
-
-$mode = collect([1, 1, 2, 4])->mode();
-
-// [1]
-
-$mode = collect([1, 1, 2, 2])->mode();
-
-// [1, 2]
-```
-
-
-#### `nth()`
-
-The `nth` method creates a new collection consisting of every n-th element:
-
-```php
-$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);
-
-$collection->nth(4);
-
-// ['a', 'e']
-```
-
-You may optionally pass a starting offset as the second argument:
-
-```php
-$collection->nth(4, 1);
-
-// ['b', 'f']
-```
-
-
-#### `only()`
-
-The `only` method returns the items in the collection with the specified keys:
-
-```php
-$collection = collect([
- 'product_id' => 1,
- 'name' => 'Desk',
- 'price' => 100,
- 'discount' => false
-]);
-
-$filtered = $collection->only(['product_id', 'name']);
-
-$filtered->all();
-
-// ['product_id' => 1, 'name' => 'Desk']
-```
-
-For the inverse of `only`, see the [except](#method-except) method.
-
-::: note
-This method's behavior is modified when using [Eloquent Collections](/docs/eloquent-collections#method-only).
-:::
-
-
-#### `pad()`
-
-The `pad` method will fill the array with the given value until the array reaches the specified size. This method behaves like the [array_pad](https://secure.php.net/manual/en/function.array-pad.php) PHP function.
-
-To pad to the left, you should specify a negative size. No padding will take place if the absolute value of the given size is less than or equal to the length of the array:
-
-```php
-$collection = collect(['A', 'B', 'C']);
-
-$filtered = $collection->pad(5, 0);
-
-$filtered->all();
-
-// ['A', 'B', 'C', 0, 0]
-
-$filtered = $collection->pad(-5, 0);
-
-$filtered->all();
-
-// [0, 0, 'A', 'B', 'C']
-```
-
-
-#### `partition()`
-
-The `partition` method may be combined with PHP array destructuring to separate elements that pass a given truth test from those that do not:
-
-```php
-$collection = collect([1, 2, 3, 4, 5, 6]);
-
-[$underThree, $equalOrAboveThree] = $collection->partition(function (int $i) {
- return $i < 3;
-});
-
-$underThree->all();
-
-// [1, 2]
-
-$equalOrAboveThree->all();
-
-// [3, 4, 5, 6]
-```
-
-
-#### `percentage()`
-
-The `percentage` method may be used to quickly determine the percentage of items in the collection that pass a given truth test:
-
-```php
-$collection = collect([1, 1, 2, 2, 2, 3]);
-
-$percentage = $collection->percentage(fn ($value) => $value === 1);
-
-// 33.33
-```
-
-By default, the percentage will be rounded to two decimal places. However, you may customize this behavior by providing a second argument to the method:
-
-```php
-$percentage = $collection->percentage(fn ($value) => $value === 1, precision: 3);
-
-// 33.333
-```
-
-
-#### `pipe()`
-
-The `pipe` method passes the collection to the given closure and returns the result of the executed closure:
-
-```php
-$collection = collect([1, 2, 3]);
-
-$piped = $collection->pipe(function (Collection $collection) {
- return $collection->sum();
-});
-
-// 6
-```
-
-
-#### `pipeInto()`
-
-The `pipeInto` method creates a new instance of the given class and passes the collection into the constructor:
-
-```php
-class ResourceCollection
-{
- /**
- * Create a new ResourceCollection instance.
- */
- public function __construct(
- public Collection $collection,
- ) {}
-}
-
-$collection = collect([1, 2, 3]);
-
-$resource = $collection->pipeInto(ResourceCollection::class);
-
-$resource->collection->all();
-
-// [1, 2, 3]
-```
-
-
-#### `pipeThrough()`
-
-The `pipeThrough` method passes the collection to the given array of closures and returns the result of the executed closures:
-
-```php
-use Hypervel\Support\Collection;
-
-$collection = collect([1, 2, 3]);
-
-$result = $collection->pipeThrough([
- function (Collection $collection) {
- return $collection->merge([4, 5]);
- },
- function (Collection $collection) {
- return $collection->sum();
- },
-]);
-
-// 15
-```
-
-
-#### `pluck()`
-
-The `pluck` method retrieves all of the values for a given key:
-
-```php
-$collection = collect([
- ['product_id' => 'prod-100', 'name' => 'Desk'],
- ['product_id' => 'prod-200', 'name' => 'Chair'],
-]);
-
-$plucked = $collection->pluck('name');
-
-$plucked->all();
-
-// ['Desk', 'Chair']
-```
-
-You may also specify how you wish the resulting collection to be keyed:
-
-```php
-$plucked = $collection->pluck('name', 'product_id');
-
-$plucked->all();
-
-// ['prod-100' => 'Desk', 'prod-200' => 'Chair']
-```
-
-The `pluck` method also supports retrieving nested values using "dot" notation:
-
-```php
-$collection = collect([
- [
- 'name' => 'Laracon',
- 'speakers' => [
- 'first_day' => ['Rosa', 'Judith'],
- ],
- ],
- [
- 'name' => 'VueConf',
- 'speakers' => [
- 'first_day' => ['Abigail', 'Joey'],
- ],
- ],
-]);
-
-$plucked = $collection->pluck('speakers.first_day');
-
-$plucked->all();
-
-// [['Rosa', 'Judith'], ['Abigail', 'Joey']]
-```
-
-If duplicate keys exist, the last matching element will be inserted into the plucked collection:
-
-```php
-$collection = collect([
- ['brand' => 'Tesla', 'color' => 'red'],
- ['brand' => 'Pagani', 'color' => 'white'],
- ['brand' => 'Tesla', 'color' => 'black'],
- ['brand' => 'Pagani', 'color' => 'orange'],
-]);
-
-$plucked = $collection->pluck('color', 'brand');
-
-$plucked->all();
-
-// ['Tesla' => 'black', 'Pagani' => 'orange']
-```
-
-
-#### `pop()`
-
-The `pop` method removes and returns the last item from the collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$collection->pop();
-
-// 5
-
-$collection->all();
-
-// [1, 2, 3, 4]
-```
-
-You may pass an integer to the `pop` method to remove and return multiple items from the end of a collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$collection->pop(3);
-
-// collect([5, 4, 3])
-
-$collection->all();
-
-// [1, 2]
-```
-
-
-#### `prepend()`
-
-The `prepend` method adds an item to the beginning of the collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$collection->prepend(0);
-
-$collection->all();
-
-// [0, 1, 2, 3, 4, 5]
-```
-
-You may also pass a second argument to specify the key of the prepended item:
-
-```php
-$collection = collect(['one' => 1, 'two' => 2]);
-
-$collection->prepend(0, 'zero');
-
-$collection->all();
-
-// ['zero' => 0, 'one' => 1, 'two' => 2]
-```
-
-
-#### `pull()`
-
-The `pull` method removes and returns an item from the collection by its key:
-
-```php
-$collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']);
-
-$collection->pull('name');
-
-// 'Desk'
-
-$collection->all();
-
-// ['product_id' => 'prod-100']
-```
-
-
-#### `push()`
-
-The `push` method appends an item to the end of the collection:
-
-```php
-$collection = collect([1, 2, 3, 4]);
-
-$collection->push(5);
-
-$collection->all();
-
-// [1, 2, 3, 4, 5]
-```
-
-
-#### `put()`
-
-The `put` method sets the given key and value in the collection:
-
-```php
-$collection = collect(['product_id' => 1, 'name' => 'Desk']);
-
-$collection->put('price', 100);
-
-$collection->all();
-
-// ['product_id' => 1, 'name' => 'Desk', 'price' => 100]
-```
-
-
-#### `random()`
-
-The `random` method returns a random item from the collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$collection->random();
-
-// 4 - (retrieved randomly)
-```
-
-You may pass an integer to `random` to specify how many items you would like to randomly retrieve. A collection of items is always returned when explicitly passing the number of items you wish to receive:
-
-```php
-$random = $collection->random(3);
-
-$random->all();
-
-// [2, 4, 5] - (retrieved randomly)
-```
-
-If the collection instance has fewer items than requested, the `random` method will throw an `InvalidArgumentException`.
-
-The `random` method also accepts a closure, which will receive the current collection instance:
-
-```php
-use Hypervel\Support\Collection;
-
-$random = $collection->random(fn (Collection $items) => min(10, count($items)));
-
-$random->all();
-
-// [1, 2, 3, 4, 5] - (retrieved randomly)
-```
-
-
-#### `range()`
-
-The `range` method returns a collection containing integers between the specified range:
-
-```php
-$collection = collect()->range(3, 6);
-
-$collection->all();
-
-// [3, 4, 5, 6]
-```
-
-
-#### `reduce()`
-
-The `reduce` method reduces the collection to a single value, passing the result of each iteration into the subsequent iteration:
-
-```php
-$collection = collect([1, 2, 3]);
-
-$total = $collection->reduce(function (?int $carry, int $item) {
- return $carry + $item;
-});
-
-// 6
-```
-
-The value for `$carry` on the first iteration is `null`; however, you may specify its initial value by passing a second argument to `reduce`:
-
-```php
-$collection->reduce(function (int $carry, int $item) {
- return $carry + $item;
-}, 4);
-
-// 10
-```
-
-The `reduce` method also passes array keys in associative collections to the given callback:
-
-```php
-$collection = collect([
- 'usd' => 1400,
- 'gbp' => 1200,
- 'eur' => 1000,
-]);
-
-$ratio = [
- 'usd' => 1,
- 'gbp' => 1.37,
- 'eur' => 1.22,
-];
-
-$collection->reduce(function (int $carry, int $value, int $key) use ($ratio) {
- return $carry + ($value * $ratio[$key]);
-});
-
-// 4264
-```
-
-
-#### `reduceSpread()`
-
-The `reduceSpread` method reduces the collection to an array of values, passing the results of each iteration into the subsequent iteration. This method is similar to the `reduce` method; however, it can accept multiple initial values:
-
-```php
-[$creditsRemaining, $batch] = Image::where('status', 'unprocessed')
- ->get()
- ->reduceSpread(function (int $creditsRemaining, Collection $batch, Image $image) {
- if ($creditsRemaining >= $image->creditsRequired()) {
- $batch->push($image);
-
- $creditsRemaining -= $image->creditsRequired();
- }
-
- return [$creditsRemaining, $batch];
- }, $creditsAvailable, collect());
-```
-
-
-#### `reject()`
-
-The `reject` method filters the collection using the given closure. The closure should return `true` if the item should be removed from the resulting collection:
-
-```php
-$collection = collect([1, 2, 3, 4]);
-
-$filtered = $collection->reject(function (int $value, int $key) {
- return $value > 2;
-});
-
-$filtered->all();
-
-// [1, 2]
-```
-
-For the inverse of the `reject` method, see the [`filter`](#method-filter) method.
-
-
-#### `replace()`
-
-The `replace` method behaves similarly to `merge`; however, in addition to overwriting matching items that have string keys, the `replace` method will also overwrite items in the collection that have matching numeric keys:
-
-```php
-$collection = collect(['Taylor', 'Abigail', 'James']);
-
-$replaced = $collection->replace([1 => 'Victoria', 3 => 'Finn']);
-
-$replaced->all();
-
-// ['Taylor', 'Victoria', 'James', 'Finn']
-```
-
-
-#### `replaceRecursive()`
-
-This method works like `replace`, but it will recur into arrays and apply the same replacement process to the inner values:
-
-```php
-$collection = collect([
- 'Taylor',
- 'Abigail',
- [
- 'James',
- 'Victoria',
- 'Finn'
- ]
-]);
-
-$replaced = $collection->replaceRecursive([
- 'Charlie',
- 2 => [1 => 'King']
-]);
-
-$replaced->all();
-
-// ['Charlie', 'Abigail', ['James', 'King', 'Finn']]
-```
-
-
-#### `reverse()`
-
-The `reverse` method reverses the order of the collection's items, preserving the original keys:
-
-```php
-$collection = collect(['a', 'b', 'c', 'd', 'e']);
-
-$reversed = $collection->reverse();
-
-$reversed->all();
-
-/*
- [
- 4 => 'e',
- 3 => 'd',
- 2 => 'c',
- 1 => 'b',
- 0 => 'a',
- ]
-*/
-```
-
-
-#### `search()`
-
-The `search` method searches the collection for the given value and returns its key if found. If the item is not found, `false` is returned:
-
-```php
-$collection = collect([2, 4, 6, 8]);
-
-$collection->search(4);
-
-// 1
-```
-
-The search is done using a "loose" comparison, meaning a string with an integer value will be considered equal to an integer of the same value. To use "strict" comparison, pass `true` as the second argument to the method:
-
-```php
-collect([2, 4, 6, 8])->search('4', $strict = true);
-
-// false
-```
-
-Alternatively, you may provide your own closure to search for the first item that passes a given truth test:
-
-```php
-collect([2, 4, 6, 8])->search(function (int $item, int $key) {
- return $item > 5;
-});
-
-// 2
-```
-
-
-#### `select()`
-
-The `select` method selects the given keys from the collection, similar to an SQL `SELECT` statement:
-
-```php
-$users = collect([
- ['name' => 'Taylor Otwell', 'role' => 'Developer', 'status' => 'active'],
- ['name' => 'Victoria Faith', 'role' => 'Researcher', 'status' => 'active'],
-]);
-
-$users->select(['name', 'role']);
-
-/*
- [
- ['name' => 'Taylor Otwell', 'role' => 'Developer'],
- ['name' => 'Victoria Faith', 'role' => 'Researcher'],
- ],
-*/
-```
-
-
-#### `shift()`
-
-The `shift` method removes and returns the first item from the collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$collection->shift();
-
-// 1
-
-$collection->all();
-
-// [2, 3, 4, 5]
-```
-
-You may pass an integer to the `shift` method to remove and return multiple items from the beginning of a collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$collection->shift(3);
-
-// collect([1, 2, 3])
-
-$collection->all();
-
-// [4, 5]
-```
-
-
-#### `shuffle()`
-
-The `shuffle` method randomly shuffles the items in the collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$shuffled = $collection->shuffle();
-
-$shuffled->all();
-
-// [3, 2, 5, 1, 4] - (generated randomly)
-```
-
-
-#### `skip()`
-
-The `skip` method returns a new collection, with the given number of elements removed from the beginning of the collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-
-$collection = $collection->skip(4);
-
-$collection->all();
-
-// [5, 6, 7, 8, 9, 10]
-```
-
-
-#### `skipUntil()`
-
-The `skipUntil` method skips over items from the collection until the given callback returns `true` and then returns the remaining items in the collection as a new collection instance:
-
-```php
-$collection = collect([1, 2, 3, 4]);
-
-$subset = $collection->skipUntil(function (int $item) {
- return $item >= 3;
-});
-
-$subset->all();
-
-// [3, 4]
-```
-
-You may also pass a simple value to the `skipUntil` method to skip all items until the given value is found:
-
-```php
-$collection = collect([1, 2, 3, 4]);
-
-$subset = $collection->skipUntil(3);
-
-$subset->all();
-
-// [3, 4]
-```
-
-::: warning
-If the given value is not found or the callback never returns `true`, the `skipUntil` method will return an empty collection.
-:::
-
-
-#### `skipWhile()`
-
-The `skipWhile` method skips over items from the collection while the given callback returns `true` and then returns the remaining items in the collection as a new collection:
-
-```php
-$collection = collect([1, 2, 3, 4]);
-
-$subset = $collection->skipWhile(function (int $item) {
- return $item <= 3;
-});
-
-$subset->all();
-
-// [4]
-```
-
-::: warning
-If the callback never returns `false`, the `skipWhile` method will return an empty collection.
-:::
-
-
-#### `slice()`
-
-The `slice` method returns a slice of the collection starting at the given index:
-
-```php
-$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-
-$slice = $collection->slice(4);
-
-$slice->all();
-
-// [5, 6, 7, 8, 9, 10]
-```
-
-If you would like to limit the size of the returned slice, pass the desired size as the second argument to the method:
-
-```php
-$slice = $collection->slice(4, 2);
-
-$slice->all();
-
-// [5, 6]
-```
-
-The returned slice will preserve keys by default. If you do not wish to preserve the original keys, you can use the [`values`](#method-values) method to reindex them.
-
-
-#### `sliding()`
-
-The `sliding` method returns a new collection of chunks representing a "sliding window" view of the items in the collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$chunks = $collection->sliding(2);
-
-$chunks->toArray();
-
-// [[1, 2], [2, 3], [3, 4], [4, 5]]
-```
-
-This is especially useful in conjunction with the [`eachSpread`](#method-eachspread) method:
-
-```php
- $transactions->sliding(2)->eachSpread(function (Collection $previous, Collection $current) {
- $current->total = $previous->total + $current->amount;
- });
-
-You may optionally pass a second "step" value, which determines the distance between the first item of every chunk:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$chunks = $collection->sliding(3, step: 2);
-
-$chunks->toArray();
-
-// [[1, 2, 3], [3, 4, 5]]
-```
-
-
-#### `sole()`
-
-The `sole` method returns the first element in the collection that passes a given truth test, but only if the truth test matches exactly one element:
-
-```php
-collect([1, 2, 3, 4])->sole(function (int $value, int $key) {
- return $value === 2;
-});
-
-// 2
-```
-
-You may also pass a key / value pair to the `sole` method, which will return the first element in the collection that matches the given pair, but only if it exactly one element matches:
-
-```php
-$collection = collect([
- ['product' => 'Desk', 'price' => 200],
- ['product' => 'Chair', 'price' => 100],
-]);
-
-$collection->sole('product', 'Chair');
-
-// ['product' => 'Chair', 'price' => 100]
-```
-
-Alternatively, you may also call the `sole` method with no argument to get the first element in the collection if there is only one element:
-
-```php
-$collection = collect([
- ['product' => 'Desk', 'price' => 200],
-]);
-
-$collection->sole();
-
-// ['product' => 'Desk', 'price' => 200]
-```
-
-If there are no elements in the collection that should be returned by the `sole` method, an `\Hyperf\Collection\ItemNotFoundException` exception will be thrown. If there is more than one element that should be returned, an `\Hyperf\Collection\MultipleItemsFoundException` will be thrown.
-
-
-#### `some()`
-
-Alias for the [`contains`](#method-contains) method.
-
-
-#### `sort()`
-
-The `sort` method sorts the collection. The sorted collection keeps the original array keys, so in the following example we will use the [`values`](#method-values) method to reset the keys to consecutively numbered indexes:
-
-```php
-$collection = collect([5, 3, 1, 2, 4]);
-
-$sorted = $collection->sort();
-
-$sorted->values()->all();
-
-// [1, 2, 3, 4, 5]
-```
-
-If your sorting needs are more advanced, you may pass a callback to `sort` with your own algorithm. Refer to the PHP documentation on [`uasort`](https://secure.php.net/manual/en/function.uasort.php#refsect1-function.uasort-parameters), which is what the collection's `sort` method calls utilizes internally.
-
-::: note
-If you need to sort a collection of nested arrays or objects, see the [`sortBy`](#method-sortby) and [`sortByDesc`](#method-sortbydesc) methods.
-:::
-
-
-#### `sortBy()`
-
-The `sortBy` method sorts the collection by the given key. The sorted collection keeps the original array keys, so in the following example we will use the [`values`](#method-values) method to reset the keys to consecutively numbered indexes:
-
-```php
-$collection = collect([
- ['name' => 'Desk', 'price' => 200],
- ['name' => 'Chair', 'price' => 100],
- ['name' => 'Bookcase', 'price' => 150],
-]);
-
-$sorted = $collection->sortBy('price');
-
-$sorted->values()->all();
-
-/*
- [
- ['name' => 'Chair', 'price' => 100],
- ['name' => 'Bookcase', 'price' => 150],
- ['name' => 'Desk', 'price' => 200],
- ]
-*/
-```
-
-The `sortBy` method accepts [sort flags](https://www.php.net/manual/en/function.sort.php) as its second argument:
-
-```php
-$collection = collect([
- ['title' => 'Item 1'],
- ['title' => 'Item 12'],
- ['title' => 'Item 3'],
-]);
-
-$sorted = $collection->sortBy('title', SORT_NATURAL);
-
-$sorted->values()->all();
-
-/*
- [
- ['title' => 'Item 1'],
- ['title' => 'Item 3'],
- ['title' => 'Item 12'],
- ]
-*/
-```
-
-Alternatively, you may pass your own closure to determine how to sort the collection's values:
-
-```php
-$collection = collect([
- ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
- ['name' => 'Chair', 'colors' => ['Black']],
- ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
-]);
-
-$sorted = $collection->sortBy(function (array $product, int $key) {
- return count($product['colors']);
-});
-
-$sorted->values()->all();
-
-/*
- [
- ['name' => 'Chair', 'colors' => ['Black']],
- ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
- ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
- ]
-*/
-```
-
-If you would like to sort your collection by multiple attributes, you may pass an array of sort operations to the `sortBy` method. Each sort operation should be an array consisting of the attribute that you wish to sort by and the direction of the desired sort:
-
-```php
-$collection = collect([
- ['name' => 'Taylor Otwell', 'age' => 34],
- ['name' => 'Abigail Otwell', 'age' => 30],
- ['name' => 'Taylor Otwell', 'age' => 36],
- ['name' => 'Abigail Otwell', 'age' => 32],
-]);
-
-$sorted = $collection->sortBy([
- ['name', 'asc'],
- ['age', 'desc'],
-]);
-
-$sorted->values()->all();
-
-/*
- [
- ['name' => 'Abigail Otwell', 'age' => 32],
- ['name' => 'Abigail Otwell', 'age' => 30],
- ['name' => 'Taylor Otwell', 'age' => 36],
- ['name' => 'Taylor Otwell', 'age' => 34],
- ]
-*/
-```
-
-When sorting a collection by multiple attributes, you may also provide closures that define each sort operation:
-
-```php
-$collection = collect([
- ['name' => 'Taylor Otwell', 'age' => 34],
- ['name' => 'Abigail Otwell', 'age' => 30],
- ['name' => 'Taylor Otwell', 'age' => 36],
- ['name' => 'Abigail Otwell', 'age' => 32],
-]);
-
-$sorted = $collection->sortBy([
- fn (array $a, array $b) => $a['name'] <=> $b['name'],
- fn (array $a, array $b) => $b['age'] <=> $a['age'],
-]);
-
-$sorted->values()->all();
-
-/*
- [
- ['name' => 'Abigail Otwell', 'age' => 32],
- ['name' => 'Abigail Otwell', 'age' => 30],
- ['name' => 'Taylor Otwell', 'age' => 36],
- ['name' => 'Taylor Otwell', 'age' => 34],
- ]
-*/
-```
-
-
-#### `sortByDesc()`
-
-This method has the same signature as the [`sortBy`](#method-sortby) method, but will sort the collection in the opposite order.
-
-
-#### `sortDesc()`
-
-This method will sort the collection in the opposite order as the [`sort`](#method-sort) method:
-
-```php
-$collection = collect([5, 3, 1, 2, 4]);
-
-$sorted = $collection->sortDesc();
-
-$sorted->values()->all();
-
-// [5, 4, 3, 2, 1]
-```
-
-Unlike `sort`, you may not pass a closure to `sortDesc`. Instead, you should use the [`sort`](#method-sort) method and invert your comparison.
-
-
-#### `sortKeys()`
-
-The `sortKeys` method sorts the collection by the keys of the underlying associative array:
-
-```php
-$collection = collect([
- 'id' => 22345,
- 'first' => 'John',
- 'last' => 'Doe',
-]);
-
-$sorted = $collection->sortKeys();
-
-$sorted->all();
-
-/*
- [
- 'first' => 'John',
- 'id' => 22345,
- 'last' => 'Doe',
- ]
-*/
-```
-
-
-#### `sortKeysDesc()`
-
-This method has the same signature as the [`sortKeys`](#method-sortkeys) method, but will sort the collection in the opposite order.
-
-
-#### `sortKeysUsing()`
-
-The `sortKeysUsing` method sorts the collection by the keys of the underlying associative array using a callback:
-
-```php
-$collection = collect([
- 'ID' => 22345,
- 'first' => 'John',
- 'last' => 'Doe',
-]);
-
-$sorted = $collection->sortKeysUsing('strnatcasecmp');
-
-$sorted->all();
-
-/*
- [
- 'first' => 'John',
- 'ID' => 22345,
- 'last' => 'Doe',
- ]
-*/
-```
-
-The callback must be a comparison function that returns an integer less than, equal to, or greater than zero. For more information, refer to the PHP documentation on [`uksort`](https://www.php.net/manual/en/function.uksort.php#refsect1-function.uksort-parameters), which is the PHP function that `sortKeysUsing` method utilizes internally.
-
-
-#### `splice()`
-
-The `splice` method removes and returns a slice of items starting at the specified index:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$chunk = $collection->splice(2);
-
-$chunk->all();
-
-// [3, 4, 5]
-
-$collection->all();
-
-// [1, 2]
-```
-
-You may pass a second argument to limit the size of the resulting collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$chunk = $collection->splice(2, 1);
-
-$chunk->all();
-
-// [3]
-
-$collection->all();
-
-// [1, 2, 4, 5]
-```
-
-In addition, you may pass a third argument containing the new items to replace the items removed from the collection:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$chunk = $collection->splice(2, 1, [10, 11]);
-
-$chunk->all();
-
-// [3]
-
-$collection->all();
-
-// [1, 2, 10, 11, 4, 5]
-```
-
-
-#### `split()`
-
-The `split` method breaks a collection into the given number of groups:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$groups = $collection->split(3);
-
-$groups->all();
-
-// [[1, 2], [3, 4], [5]]
-```
-
-
-#### `splitIn()`
-
-The `splitIn` method breaks a collection into the given number of groups, filling non-terminal groups completely before allocating the remainder to the final group:
-
-```php
-$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-
-$groups = $collection->splitIn(3);
-
-$groups->all();
-
-// [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]
-```
-
-
-#### `sum()`
-
-The `sum` method returns the sum of all items in the collection:
-
- collect([1, 2, 3, 4, 5])->sum();
-
- // 15
-
-If the collection contains nested arrays or objects, you should pass a key that will be used to determine which values to sum:
-
-```php
-$collection = collect([
- ['name' => 'JavaScript: The Good Parts', 'pages' => 176],
- ['name' => 'JavaScript: The Definitive Guide', 'pages' => 1096],
-]);
-
-$collection->sum('pages');
-
-// 1272
-```
-
-In addition, you may pass your own closure to determine which values of the collection to sum:
-
-```php
-$collection = collect([
- ['name' => 'Chair', 'colors' => ['Black']],
- ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
- ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
-]);
-
-$collection->sum(function (array $product) {
- return count($product['colors']);
-});
-
-// 6
-```
-
-
-#### `take()`
-
-The `take` method returns a new collection with the specified number of items:
-
-```php
-$collection = collect([0, 1, 2, 3, 4, 5]);
-
-$chunk = $collection->take(3);
-
-$chunk->all();
-
-// [0, 1, 2]
-```
-
-You may also pass a negative integer to take the specified number of items from the end of the collection:
-
-```php
-$collection = collect([0, 1, 2, 3, 4, 5]);
-
-$chunk = $collection->take(-2);
-
-$chunk->all();
-
-// [4, 5]
-```
-
-
-#### `takeUntil()`
-
-The `takeUntil` method returns items in the collection until the given callback returns `true`:
-
-```php
-$collection = collect([1, 2, 3, 4]);
-
-$subset = $collection->takeUntil(function (int $item) {
- return $item >= 3;
-});
-
-$subset->all();
-
-// [1, 2]
-```
-
-You may also pass a simple value to the `takeUntil` method to get the items until the given value is found:
-
-```php
-$collection = collect([1, 2, 3, 4]);
-
-$subset = $collection->takeUntil(3);
-
-$subset->all();
-
-// [1, 2]
-```
-
-::: warning
-If the given value is not found or the callback never returns `true`, the `takeUntil` method will return all items in the collection.
-:::
-
-
-#### `takeWhile()`
-
-The `takeWhile` method returns items in the collection until the given callback returns `false`:
-
-```php
-$collection = collect([1, 2, 3, 4]);
-
-$subset = $collection->takeWhile(function (int $item) {
- return $item < 3;
-});
-
-$subset->all();
-
-// [1, 2]
-```
-
-::: warning
-If the callback never returns `false`, the `takeWhile` method will return all items in the collection.
-:::
-
-
-#### `tap()`
-
-The `tap` method passes the collection to the given callback, allowing you to "tap" into the collection at a specific point and do something with the items while not affecting the collection itself. The collection is then returned by the `tap` method:
-
-```php
-collect([2, 4, 3, 1, 5])
- ->sort()
- ->tap(function (Collection $collection) {
- Log::debug('Values after sorting', $collection->values()->all());
- })
- ->shift();
-
-// 1
-```
-
-
-#### `times()`
-
-The static `times` method creates a new collection by invoking the given closure a specified number of times:
-
-```php
-$collection = Collection::times(10, function (int $number) {
- return $number * 9;
-});
-
-$collection->all();
-
-// [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
-```
-
-
-#### `toArray()`
-
-The `toArray` method converts the collection into a plain PHP `array`. If the collection's values are [Eloquent](/docs/eloquent) models, the models will also be converted to arrays:
-
-```php
-$collection = collect(['name' => 'Desk', 'price' => 200]);
-
-$collection->toArray();
-
-/*
- [
- ['name' => 'Desk', 'price' => 200],
- ]
-*/
-```
-
-::: warning
-`toArray` also converts all of the collection's nested objects that are an instance of `Arrayable` to an array. If you want to get the raw array underlying the collection, use the [`all`](#method-all) method instead.
-:::
-
-
-#### `toJson()`
-
-The `toJson` method converts the collection into a JSON serialized string:
-
-```php
-$collection = collect(['name' => 'Desk', 'price' => 200]);
-
-$collection->toJson();
-
-// '{"name":"Desk", "price":200}'
-```
-
-
-#### `transform()`
-
-The `transform` method iterates over the collection and calls the given callback with each item in the collection. The items in the collection will be replaced by the values returned by the callback:
-
-```php
-$collection = collect([1, 2, 3, 4, 5]);
-
-$collection->transform(function (int $item, int $key) {
- return $item * 2;
-});
-
-$collection->all();
-
-// [2, 4, 6, 8, 10]
-```
-
-::: warning
-Unlike most other collection methods, `transform` modifies the collection itself. If you wish to create a new collection instead, use the [`map`](#method-map) method.
-:::
-
-
-#### `undot()`
-
-The `undot` method expands a single-dimensional collection that uses "dot" notation into a multi-dimensional collection:
-
-```php
-$person = collect([
- 'name.first_name' => 'Marie',
- 'name.last_name' => 'Valentine',
- 'address.line_1' => '2992 Eagle Drive',
- 'address.line_2' => '',
- 'address.suburb' => 'Detroit',
- 'address.state' => 'MI',
- 'address.postcode' => '48219'
-]);
-
-$person = $person->undot();
-
-$person->toArray();
-
-/*
- [
- "name" => [
- "first_name" => "Marie",
- "last_name" => "Valentine",
- ],
- "address" => [
- "line_1" => "2992 Eagle Drive",
- "line_2" => "",
- "suburb" => "Detroit",
- "state" => "MI",
- "postcode" => "48219",
- ],
- ]
-*/
-```
-
-
-#### `union()`
-
-The `union` method adds the given array to the collection. If the given array contains keys that are already in the original collection, the original collection's values will be preferred:
-
-```php
-$collection = collect([1 => ['a'], 2 => ['b']]);
-
-$union = $collection->union([3 => ['c'], 1 => ['d']]);
-
-$union->all();
-
-// [1 => ['a'], 2 => ['b'], 3 => ['c']]
-```
-
-
-#### `unique()`
-
-The `unique` method returns all of the unique items in the collection. The returned collection keeps the original array keys, so in the following example we will use the [`values`](#method-values) method to reset the keys to consecutively numbered indexes:
-
-```php
-$collection = collect([1, 1, 2, 2, 3, 4, 2]);
-
-$unique = $collection->unique();
-
-$unique->values()->all();
-
-// [1, 2, 3, 4]
-```
-
-When dealing with nested arrays or objects, you may specify the key used to determine uniqueness:
-
-```php
-$collection = collect([
- ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
- ['name' => 'iPhone 5', 'brand' => 'Apple', 'type' => 'phone'],
- ['name' => 'Apple Watch', 'brand' => 'Apple', 'type' => 'watch'],
- ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
- ['name' => 'Galaxy Gear', 'brand' => 'Samsung', 'type' => 'watch'],
-]);
-
-$unique = $collection->unique('brand');
-
-$unique->values()->all();
-
-/*
- [
- ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
- ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
- ]
-*/
-```
-
-Finally, you may also pass your own closure to the `unique` method to specify which value should determine an item's uniqueness:
-
-```php
-$unique = $collection->unique(function (array $item) {
- return $item['brand'].$item['type'];
-});
-
-$unique->values()->all();
-
-/*
- [
- ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
- ['name' => 'Apple Watch', 'brand' => 'Apple', 'type' => 'watch'],
- ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
- ['name' => 'Galaxy Gear', 'brand' => 'Samsung', 'type' => 'watch'],
- ]
-*/
-```
-
-The `unique` method uses "loose" comparisons when checking item values, meaning a string with an integer value will be considered equal to an integer of the same value. Use the [`uniqueStrict`](#method-uniquestrict) method to filter using "strict" comparisons.
-
-::: note
-This method's behavior is modified when using [Eloquent Collections](/docs/eloquent-collections#method-unique).
-:::
-
-
-#### `uniqueStrict()`
-
-This method has the same signature as the [`unique`](#method-unique) method; however, all values are compared using "strict" comparisons.
-
-
-#### `unless()`
-
-The `unless` method will execute the given callback unless the first argument given to the method evaluates to `true`:
-
-```php
-$collection = collect([1, 2, 3]);
-
-$collection->unless(true, function (Collection $collection) {
- return $collection->push(4);
-});
-
-$collection->unless(false, function (Collection $collection) {
- return $collection->push(5);
-});
-
-$collection->all();
-
-// [1, 2, 3, 5]
-```
-
-A second callback may be passed to the `unless` method. The second callback will be executed when the first argument given to the `unless` method evaluates to `true`:
-
-```php
-$collection = collect([1, 2, 3]);
-
-$collection->unless(true, function (Collection $collection) {
- return $collection->push(4);
-}, function (Collection $collection) {
- return $collection->push(5);
-});
-
-$collection->all();
-
-// [1, 2, 3, 5]
-```
-
-For the inverse of `unless`, see the [`when`](#method-when) method.
-
-
-#### `unlessEmpty()`
-
-Alias for the [`whenNotEmpty`](#method-whennotempty) method.
-
-
-#### `unlessNotEmpty()`
-
-Alias for the [`whenEmpty`](#method-whenempty) method.
-
-
-#### `unwrap()`
-
-The static `unwrap` method returns the collection's underlying items from the given value when applicable:
-
-```php
-Collection::unwrap(collect('John Doe'));
-
-// ['John Doe']
-
-Collection::unwrap(['John Doe']);
-
-// ['John Doe']
-
-Collection::unwrap('John Doe');
-
-// 'John Doe'
-```
-
-
-#### `value()`
-
-The `value` method retrieves a given value from the first element of the collection:
-
-```php
-$collection = collect([
- ['product' => 'Desk', 'price' => 200],
- ['product' => 'Speaker', 'price' => 400],
-]);
-
-$value = $collection->value('price');
-
-// 200
-```
-
-
-#### `values()`
-
-The `values` method returns a new collection with the keys reset to consecutive integers:
-
-```php
-$collection = collect([
- 10 => ['product' => 'Desk', 'price' => 200],
- 11 => ['product' => 'Desk', 'price' => 200],
-]);
-
-$values = $collection->values();
-
-$values->all();
-
-/*
- [
- 0 => ['product' => 'Desk', 'price' => 200],
- 1 => ['product' => 'Desk', 'price' => 200],
- ]
-*/
-```
-
-
-#### `when()`
-
-The `when` method will execute the given callback when the first argument given to the method evaluates to `true`. The collection instance and the first argument given to the `when` method will be provided to the closure:
-
-```php
-$collection = collect([1, 2, 3]);
-
-$collection->when(true, function (Collection $collection, int $value) {
- return $collection->push(4);
-});
-
-$collection->when(false, function (Collection $collection, int $value) {
- return $collection->push(5);
-});
-
-$collection->all();
-
-// [1, 2, 3, 4]
-```
-
-A second callback may be passed to the `when` method. The second callback will be executed when the first argument given to the `when` method evaluates to `false`:
-
-```php
-$collection = collect([1, 2, 3]);
-
-$collection->when(false, function (Collection $collection, int $value) {
- return $collection->push(4);
-}, function (Collection $collection) {
- return $collection->push(5);
-});
-
-$collection->all();
-
-// [1, 2, 3, 5]
-```
-
-For the inverse of `when`, see the [`unless`](#method-unless) method.
-
-
-#### `whenEmpty()`
-
-The `whenEmpty` method will execute the given callback when the collection is empty:
-
-```php
-$collection = collect(['Michael', 'Tom']);
-
-$collection->whenEmpty(function (Collection $collection) {
- return $collection->push('Adam');
-});
-
-$collection->all();
-
-// ['Michael', 'Tom']
-
-
-$collection = collect();
-
-$collection->whenEmpty(function (Collection $collection) {
- return $collection->push('Adam');
-});
-
-$collection->all();
-
-// ['Adam']
-```
-
-A second closure may be passed to the `whenEmpty` method that will be executed when the collection is not empty:
-
-```php
-$collection = collect(['Michael', 'Tom']);
-
-$collection->whenEmpty(function (Collection $collection) {
- return $collection->push('Adam');
-}, function (Collection $collection) {
- return $collection->push('Taylor');
-});
-
-$collection->all();
-
-// ['Michael', 'Tom', 'Taylor']
-```
-
-For the inverse of `whenEmpty`, see the [`whenNotEmpty`](#method-whennotempty) method.
-
-
-#### `whenNotEmpty()`
-
-The `whenNotEmpty` method will execute the given callback when the collection is not empty:
-
-```php
-$collection = collect(['michael', 'tom']);
-
-$collection->whenNotEmpty(function (Collection $collection) {
- return $collection->push('adam');
-});
-
-$collection->all();
-
-// ['michael', 'tom', 'adam']
-
-
-$collection = collect();
-
-$collection->whenNotEmpty(function (Collection $collection) {
- return $collection->push('adam');
-});
-
-$collection->all();
-
-// []
-```
-
-A second closure may be passed to the `whenNotEmpty` method that will be executed when the collection is empty:
-
-```php
-$collection = collect();
-
-$collection->whenNotEmpty(function (Collection $collection) {
- return $collection->push('adam');
-}, function (Collection $collection) {
- return $collection->push('taylor');
-});
-
-$collection->all();
-
-// ['taylor']
-```
-
-For the inverse of `whenNotEmpty`, see the [`whenEmpty`](#method-whenempty) method.
-
-
-#### `where()`
-
-The `where` method filters the collection by a given key / value pair:
-
-```php
-$collection = collect([
- ['product' => 'Desk', 'price' => 200],
- ['product' => 'Chair', 'price' => 100],
- ['product' => 'Bookcase', 'price' => 150],
- ['product' => 'Door', 'price' => 100],
-]);
-
-$filtered = $collection->where('price', 100);
-
-$filtered->all();
-
-/*
- [
- ['product' => 'Chair', 'price' => 100],
- ['product' => 'Door', 'price' => 100],
- ]
-*/
-```
-
-The `where` method uses "loose" comparisons when checking item values, meaning a string with an integer value will be considered equal to an integer of the same value. Use the [`whereStrict`](#method-wherestrict) method to filter using "strict" comparisons.
-
-Optionally, you may pass a comparison operator as the second parameter. Supported operators are: '===', '!==', '!=', '==', '=', '<>', '>', '<', '>=', and '<=':
-
-```php
-$collection = collect([
- ['name' => 'Jim', 'deleted_at' => '2019-01-01 00:00:00'],
- ['name' => 'Sally', 'deleted_at' => '2019-01-02 00:00:00'],
- ['name' => 'Sue', 'deleted_at' => null],
-]);
-
-$filtered = $collection->where('deleted_at', '!=', null);
-
-$filtered->all();
-
-/*
- [
- ['name' => 'Jim', 'deleted_at' => '2019-01-01 00:00:00'],
- ['name' => 'Sally', 'deleted_at' => '2019-01-02 00:00:00'],
- ]
-*/
-```
-
-
-#### `whereStrict()`
-
-This method has the same signature as the [`where`](#method-where) method; however, all values are compared using "strict" comparisons.
-
-
-#### `whereBetween()`
-
-The `whereBetween` method filters the collection by determining if a specified item value is within a given range:
-
-```php
-$collection = collect([
- ['product' => 'Desk', 'price' => 200],
- ['product' => 'Chair', 'price' => 80],
- ['product' => 'Bookcase', 'price' => 150],
- ['product' => 'Pencil', 'price' => 30],
- ['product' => 'Door', 'price' => 100],
-]);
-
-$filtered = $collection->whereBetween('price', [100, 200]);
-
-$filtered->all();
-
-/*
- [
- ['product' => 'Desk', 'price' => 200],
- ['product' => 'Bookcase', 'price' => 150],
- ['product' => 'Door', 'price' => 100],
- ]
-*/
-```
-
-
-#### `whereIn()`
-
-The `whereIn` method removes elements from the collection that do not have a specified item value that is contained within the given array:
-
-```php
-$collection = collect([
- ['product' => 'Desk', 'price' => 200],
- ['product' => 'Chair', 'price' => 100],
- ['product' => 'Bookcase', 'price' => 150],
- ['product' => 'Door', 'price' => 100],
-]);
-
-$filtered = $collection->whereIn('price', [150, 200]);
-
-$filtered->all();
-
-/*
- [
- ['product' => 'Desk', 'price' => 200],
- ['product' => 'Bookcase', 'price' => 150],
- ]
-*/
-```
-
-The `whereIn` method uses "loose" comparisons when checking item values, meaning a string with an integer value will be considered equal to an integer of the same value. Use the [`whereInStrict`](#method-whereinstrict) method to filter using "strict" comparisons.
-
-
-#### `whereInStrict()`
-
-This method has the same signature as the [`whereIn`](#method-wherein) method; however, all values are compared using "strict" comparisons.
-
-
-#### `whereInstanceOf()`
-
-The `whereInstanceOf` method filters the collection by a given class type:
-
-```php
-use App\Models\User;
-use App\Models\Post;
-
-$collection = collect([
- new User,
- new User,
- new Post,
-]);
-
-$filtered = $collection->whereInstanceOf(User::class);
-
-$filtered->all();
-
-// [App\Models\User, App\Models\User]
-```
-
-
-#### `whereNotBetween()`
-
-The `whereNotBetween` method filters the collection by determining if a specified item value is outside of a given range:
-
-```php
-$collection = collect([
- ['product' => 'Desk', 'price' => 200],
- ['product' => 'Chair', 'price' => 80],
- ['product' => 'Bookcase', 'price' => 150],
- ['product' => 'Pencil', 'price' => 30],
- ['product' => 'Door', 'price' => 100],
-]);
-
-$filtered = $collection->whereNotBetween('price', [100, 200]);
-
-$filtered->all();
-
-/*
- [
- ['product' => 'Chair', 'price' => 80],
- ['product' => 'Pencil', 'price' => 30],
- ]
-*/
-```
-
-
-#### `whereNotIn()`
-
-The `whereNotIn` method removes elements from the collection that have a specified item value that is contained within the given array:
-
-```php
-$collection = collect([
- ['product' => 'Desk', 'price' => 200],
- ['product' => 'Chair', 'price' => 100],
- ['product' => 'Bookcase', 'price' => 150],
- ['product' => 'Door', 'price' => 100],
-]);
-
-$filtered = $collection->whereNotIn('price', [150, 200]);
-
-$filtered->all();
-
-/*
- [
- ['product' => 'Chair', 'price' => 100],
- ['product' => 'Door', 'price' => 100],
- ]
-*/
-```
-
-The `whereNotIn` method uses "loose" comparisons when checking item values, meaning a string with an integer value will be considered equal to an integer of the same value. Use the [`whereNotInStrict`](#method-wherenotinstrict) method to filter using "strict" comparisons.
-
-
-#### `whereNotInStrict()`
-
-This method has the same signature as the [`whereNotIn`](#method-wherenotin) method; however, all values are compared using "strict" comparisons.
-
-
-#### `whereNotNull()`
-
-The `whereNotNull` method returns items from the collection where the given key is not `null`:
-
-```php
-$collection = collect([
- ['name' => 'Desk'],
- ['name' => null],
- ['name' => 'Bookcase'],
-]);
-
-$filtered = $collection->whereNotNull('name');
-
-$filtered->all();
-
-/*
- [
- ['name' => 'Desk'],
- ['name' => 'Bookcase'],
- ]
-*/
-```
-
-
-#### `whereNull()`
-
-The `whereNull` method returns items from the collection where the given key is `null`:
-
-```php
-$collection = collect([
- ['name' => 'Desk'],
- ['name' => null],
- ['name' => 'Bookcase'],
-]);
-
-$filtered = $collection->whereNull('name');
-
-$filtered->all();
-
-/*
- [
- ['name' => null],
- ]
-*/
-```
-
-
-#### `wrap()`
-
-The static `wrap` method wraps the given value in a collection when applicable:
-
-```php
-use Hypervel\Support\Collection;
-
-$collection = Collection::wrap('John Doe');
-
-$collection->all();
-
-// ['John Doe']
-
-$collection = Collection::wrap(['John Doe']);
-
-$collection->all();
-
-// ['John Doe']
-
-$collection = Collection::wrap(collect('John Doe'));
-
-$collection->all();
-
-// ['John Doe']
-```
-
-
-#### `zip()`
-
-The `zip` method merges together the values of the given array with the values of the original collection at their corresponding index:
-
-```php
-$collection = collect(['Chair', 'Desk']);
-
-$zipped = $collection->zip([100, 200]);
-
-$zipped->all();
-
-// [['Chair', 100], ['Desk', 200]]
-```
-
-
-## Higher Order Messages
-
-Collections also provide support for "higher order messages", which are short-cuts for performing common actions on collections. The collection methods that provide higher order messages are: [`average`](#method-average), [`avg`](#method-avg), [`contains`](#method-contains), [`each`](#method-each), [`every`](#method-every), [`filter`](#method-filter), [`first`](#method-first), [`flatMap`](#method-flatmap), [`groupBy`](#method-groupby), [`keyBy`](#method-keyby), [`map`](#method-map), [`max`](#method-max), [`min`](#method-min), [`partition`](#method-partition), [`reject`](#method-reject), [`skipUntil`](#method-skipuntil), [`skipWhile`](#method-skipwhile), [`some`](#method-some), [`sortBy`](#method-sortby), [`sortByDesc`](#method-sortbydesc), [`sum`](#method-sum), [`takeUntil`](#method-takeuntil), [`takeWhile`](#method-takewhile), and [`unique`](#method-unique).
-
-Each higher order message can be accessed as a dynamic property on a collection instance. For instance, let's use the `each` higher order message to call a method on each object within a collection:
-
-```php
-use App\Models\User;
-
-$users = User::where('votes', '>', 500)->get();
-
-$users->each->markAsVip();
-```
-
-Likewise, we can use the `sum` higher order message to gather the total number of "votes" for a collection of users:
-
-```php
-$users = User::where('group', 'Development')->get();
-
-return $users->sum->votes;
-```
-
-
-## Lazy Collections
-
-
-### Introduction
-
-::: warning
-Before learning more about Hypervel's lazy collections, take some time to familiarize yourself with [PHP generators](https://www.php.net/manual/en/language.generators.overview.php).
-:::
-
-To supplement the already powerful `Collection` class, the `LazyCollection` class leverages PHP's [generators](https://www.php.net/manual/en/language.generators.overview.php) to allow you to work with very large datasets while keeping memory usage low.
-
-For example, imagine your application needs to process a multi-gigabyte log file while taking advantage of Hypervel's collection methods to parse the logs. Instead of reading the entire file into memory at once, lazy collections may be used to keep only a small part of the file in memory at a given time:
-
-```php
-use App\Models\LogEntry;
-use Hyperf\Collection\LazyCollection;
-
-LazyCollection::make(function () {
- $handle = fopen('log.txt', 'r');
-
- while (($line = fgets($handle)) !== false) {
- yield $line;
- }
-})->chunk(4)->map(function (array $lines) {
- return LogEntry::fromLines($lines);
-})->each(function (LogEntry $logEntry) {
- // Process the log entry...
-});
-```
-
-Or, imagine you need to iterate through 10,000 Eloquent models. When using traditional Hypervel collections, all 10,000 Eloquent models must be loaded into memory at the same time:
-
-```php
-use App\Models\User;
-
-$users = User::all()->filter(function (User $user) {
- return $user->id > 500;
-});
-```
-
-However, the query builder's `cursor` method returns a `LazyCollection` instance. This allows you to still only run a single query against the database but also only keep one Eloquent model loaded in memory at a time. In this example, the `filter` callback is not executed until we actually iterate over each user individually, allowing for a drastic reduction in memory usage:
-
-```php
-use App\Models\User;
-
-$users = User::cursor()->filter(function (User $user) {
- return $user->id > 500;
-});
-
-foreach ($users as $user) {
- echo $user->id;
-}
-```
-
-
-### Creating Lazy Collections
-
-To create a lazy collection instance, you should pass a PHP generator function to the collection's `make` method:
-
-```php
-use Hyperf\Collection\LazyCollection;
-
-LazyCollection::make(function () {
- $handle = fopen('log.txt', 'r');
-
- while (($line = fgets($handle)) !== false) {
- yield $line;
- }
-});
-```
-
-
-### The Enumerable Contract
-
-Almost all methods available on the `Collection` class are also available on the `LazyCollection` class. Both of these classes implement the `Hyperf\Collection\Enumerable` contract, which defines the following methods:
-
-
-
-{{ $product->name }}
- @endforeach
-
-
-[all](#method-all)
-[average](#method-average)
-[avg](#method-avg)
-[chunk](#method-chunk)
-[chunkWhile](#method-chunkwhile)
-[collapse](#method-collapse)
-[collect](#method-collect)
-[combine](#method-combine)
-[concat](#method-concat)
-[contains](#method-contains)
-[containsStrict](#method-containsstrict)
-[count](#method-count)
-[countBy](#method-countBy)
-[crossJoin](#method-crossjoin)
-[dd](#method-dd)
-[diff](#method-diff)
-[diffAssoc](#method-diffassoc)
-[diffKeys](#method-diffkeys)
-[dump](#method-dump)
-[duplicates](#method-duplicates)
-[duplicatesStrict](#method-duplicatesstrict)
-[each](#method-each)
-[eachSpread](#method-eachspread)
-[every](#method-every)
-[except](#method-except)
-[filter](#method-filter)
-[first](#method-first)
-[firstOrFail](#method-first-or-fail)
-[firstWhere](#method-first-where)
-[flatMap](#method-flatmap)
-[flatten](#method-flatten)
-[flip](#method-flip)
-[forPage](#method-forpage)
-[get](#method-get)
-[groupBy](#method-groupby)
-[has](#method-has)
-[implode](#method-implode)
-[intersect](#method-intersect)
-[intersectAssoc](#method-intersectAssoc)
-[intersectByKeys](#method-intersectbykeys)
-[isEmpty](#method-isempty)
-[isNotEmpty](#method-isnotempty)
-[join](#method-join)
-[keyBy](#method-keyby)
-[keys](#method-keys)
-[last](#method-last)
-[macro](#method-macro)
-[make](#method-make)
-[map](#method-map)
-[mapInto](#method-mapinto)
-[mapSpread](#method-mapspread)
-[mapToGroups](#method-maptogroups)
-[mapWithKeys](#method-mapwithkeys)
-[max](#method-max)
-[median](#method-median)
-[merge](#method-merge)
-[mergeRecursive](#method-mergerecursive)
-[min](#method-min)
-[mode](#method-mode)
-[nth](#method-nth)
-[only](#method-only)
-[pad](#method-pad)
-[partition](#method-partition)
-[pipe](#method-pipe)
-[pluck](#method-pluck)
-[random](#method-random)
-[reduce](#method-reduce)
-[reject](#method-reject)
-[replace](#method-replace)
-[replaceRecursive](#method-replacerecursive)
-[reverse](#method-reverse)
-[search](#method-search)
-[shuffle](#method-shuffle)
-[skip](#method-skip)
-[slice](#method-slice)
-[sole](#method-sole)
-[some](#method-some)
-[sort](#method-sort)
-[sortBy](#method-sortby)
-[sortByDesc](#method-sortbydesc)
-[sortKeys](#method-sortkeys)
-[sortKeysDesc](#method-sortkeysdesc)
-[split](#method-split)
-[sum](#method-sum)
-[take](#method-take)
-[tap](#method-tap)
-[times](#method-times)
-[toArray](#method-toarray)
-[toJson](#method-tojson)
-[union](#method-union)
-[unique](#method-unique)
-[uniqueStrict](#method-uniquestrict)
-[unless](#method-unless)
-[unlessEmpty](#method-unlessempty)
-[unlessNotEmpty](#method-unlessnotempty)
-[unwrap](#method-unwrap)
-[values](#method-values)
-[when](#method-when)
-[whenEmpty](#method-whenempty)
-[whenNotEmpty](#method-whennotempty)
-[where](#method-where)
-[whereStrict](#method-wherestrict)
-[whereBetween](#method-wherebetween)
-[whereIn](#method-wherein)
-[whereInStrict](#method-whereinstrict)
-[whereInstanceOf](#method-whereinstanceof)
-[whereNotBetween](#method-wherenotbetween)
-[whereNotIn](#method-wherenotin)
-[whereNotInStrict](#method-wherenotinstrict)
-[wrap](#method-wrap)
-[zip](#method-zip)
-
-
-
-::: warning
-Methods that mutate the collection (such as `shift`, `pop`, `prepend` etc.) are **not** available on the `LazyCollection` class.
-:::
-
-
-### Lazy Collection Methods
-
-In addition to the methods defined in the `Enumerable` contract, the `LazyCollection` class contains the following methods:
-
-
-#### `takeUntilTimeout()`
-
-The `takeUntilTimeout` method returns a new lazy collection that will enumerate values until the specified time. After that time, the collection will then stop enumerating:
-
-```php
-$lazyCollection = LazyCollection::times(INF)
- ->takeUntilTimeout(now()->addMinute());
-
-$lazyCollection->each(function (int $number) {
- dump($number);
-
- sleep(1);
-});
-
-// 1
-// 2
-// ...
-// 58
-// 59
-```
-
-To illustrate the usage of this method, imagine an application that submits invoices from the database using a cursor. You could define a [scheduled task](/docs/scheduling) that runs every 15 minutes and only processes invoices for a maximum of 14 minutes:
-
-```php
-use App\Models\Invoice;
-use Carbon\Carbon;
-
-Invoice::pending()->cursor()
- ->takeUntilTimeout(
- Carbon::createFromTimestamp(LARAVEL_HYPERF_START)->add(14, 'minutes')
- )
- ->each(fn (Invoice $invoice) => $invoice->submit());
-```
-
-
-#### `tapEach()`
-
-While the `each` method calls the given callback for each item in the collection right away, the `tapEach` method only calls the given callback as the items are being pulled out of the list one by one:
-
-```php
-// Nothing has been dumped so far...
-$lazyCollection = LazyCollection::times(INF)->tapEach(function (int $value) {
- dump($value);
-});
-
-// Three items are dumped...
-$array = $lazyCollection->take(3)->all();
-
-// 1
-// 2
-// 3
-```
-
-
-#### `remember()`
-
-The `remember` method returns a new lazy collection that will remember any values that have already been enumerated and will not retrieve them again on subsequent collection enumerations:
-
-```php
-// No query has been executed yet...
-$users = User::cursor()->remember();
-
-// The query is executed...
-// The first 5 users are hydrated from the database...
-$users->take(5)->all();
-
-// First 5 users come from the collection's cache...
-// The rest are hydrated from the database...
-$users->take(20)->all();
-```
diff --git a/_archive/docs/0.3/docs/configuration.md b/_archive/docs/0.3/docs/configuration.md
deleted file mode 100644
index 9f14d7d8bf..0000000000
--- a/_archive/docs/0.3/docs/configuration.md
+++ /dev/null
@@ -1,178 +0,0 @@
-# Configuration
-[[toc]]
-
-## Introduction
-
-All of the configuration files for the Hypervel framework are stored in the `config` directory. Each option is documented, so feel free to look through the files and get familiar with the options available to you.
-
-These configuration files allow you to configure things like your database connection information, your mail server information, as well as various other core configuration values such as your application URL and encryption key.
-
-### The `about` Command
-
-Hypervel can display an overview of your application's configuration, drivers, and environment via the `about` Artisan command.
-
-```shell:no-line-numbers
-php artisan about
-```
-
-If you're only interested in a particular section of the application overview output, you may filter for that section using the `--only` option:
-
-```shell:no-line-numbers
-php artisan about --only=environment
-```
-
-Or, to explore a specific configuration file's values in detail, you may use the `config:show` Artisan command:
-
-```shell:no-line-numbers
-php artisan config:show database
-```
-
-## Unsupported Recursive Config Resolution
-
-Since Hypervel initializes the Configuration service at a very early stage in the framework's underlying mechanism, which differs from Laravel, the related configs are loaded into the framework at an extremely early phase.
-
-At this point, **Config Instance** is not ready while reading config files. This means you shouldn't refer to other config values in the config files.
-
-For example, you will get errors with the following config declaration:
-
-```php
-return [
- 'foo' => config('bar.title'),
-];
-```
-
-::: warning
-Some special config files will be loaded by Hypervel before the app container is ready, such as `config/app.php`, `config/dependencies.php`, `config/annotations.php`. You shouldn't call any functions that will require app container in these config files.
-:::
-
-## Environment Configuration
-
-It is often helpful to have different configuration values based on the environment where the application is running. For example, you may wish to use a different cache driver locally than you do on your production server.
-
-To make this a cinch, Hypervel utilizes the [DotEnv](https://github.com/vlucas/phpdotenv) PHP library. In a fresh Hypervel installation, the root directory of your application will contain a `.env.example` file that defines many common environment variables. During the Hypervel installation process, this file will automatically be copied to `.env`.
-
-Hypervel's default `.env` file contains some common configuration values that may differ based on whether your application is running locally or on a production web server. These values are then read by the configuration files within the `config` directory using Hypervel's `env` function.
-
-If you are developing with a team, you may wish to continue including and updating the `.env.example` file with your application. By putting placeholder values in the example configuration file, other developers on your team can clearly see which environment variables are needed to run your application.
-
-::: note
-Any variable in your `.env` file can be overridden by external environment variables such as server-level or system-level environment variables.
-:::
-
-#### Environment File Security
-
-Your `.env` file should not be committed to your application's source control, since each developer / server using your application could require a different environment configuration. Furthermore, this would be a security risk in the event an intruder gains access to your source control repository, since any sensitive credentials would get exposed.
-
-### Environment Variable Types
-
-All variables in your `.env` files are typically parsed as strings, so some reserved values have been created to allow you to return a wider range of types from the `env()` function:
-
-
-
-| `.env` Value | `env()` Value |
-| ------------ | ------------- |
-| true | (bool) true |
-| (true) | (bool) true |
-| false | (bool) false |
-| (false) | (bool) false |
-| empty | (string) '' |
-| (empty) | (string) '' |
-| null | (null) null |
-| (null) | (null) null |
-
-
-
-If you need to define an environment variable with a value that contains spaces, you may do so by enclosing the value in double quotes:
-
-```ini
-APP_NAME="My Application"
-```
-
-### Retrieving Environment Configuration
-
-You can use the `env` function to retrieve values from these variables in your configuration files. In fact, if you review the Hypervel configuration files, you will notice many of the options are already using this function:
-
-```php
-'debug' => env('APP_DEBUG', false),
-```
-
-The second value passed to the `env` function is the "default value". This value will be returned if no environment variable exists for the given key.
-
-### Determining the Current Environment
-
-The current application environment is determined via the `APP_ENV` variable from your `.env` file. You may access this value via the `environment` method on the `App` [facade](/docs/facades):
-
-```php
-use Hypervel\Support\Facades\App;
-
-$environment = App::environment();
-```
-
-You may also pass arguments to the `environment` method to determine if the environment matches a given value. The method will return `true` if the environment matches any of the given values:
-
-```php
-if (App::environment('local')) {
- // The environment is local
-}
-
-if (App::environment(['local', 'staging'])) {
- // The environment is either local OR staging...
-}
-```
-
-::: note
-The current application environment detection can be overridden by defining a server-level `APP_ENV` environment variable.
-:::
-
-## Accessing Configuration Values
-
-You may easily access your configuration values using the `Config` facade or global `config` function from anywhere in your application. The configuration values may be accessed using "dot" syntax, which includes the name of the file and option you wish to access. A default value may also be specified and will be returned if the configuration option does not exist:
-
-```php
-use Hypervel\Support\Facades\Config;
-
-$value = Config::get('app.timezone');
-
-$value = config('app.timezone');
-
-// Retrieve a default value if the configuration value does not exist...
-$value = config('app.timezone', 'Asia/Seoul');
-```
-
-To set configuration values at runtime, you may invoke the `Config` facade's `set` method or pass an array to the `config` function:
-
-```php
-Config::set('app.timezone', 'America/Chicago');
-
-config(['app.timezone' => 'America/Chicago']);
-```
-
-To assist with static analysis, the `Config` facade also provides typed configuration retrieval methods. If the retrieved configuration value does not match the expected type, an exception will be thrown:
-
-```php
-Config::string('config-key');
-Config::integer('config-key');
-Config::float('config-key');
-Config::boolean('config-key');
-Config::array('config-key');
-```
-
-## Configuration Publishing
-
-Most of Hypervel's configuration files are already published in your application's `config` directory; however, certain configuration files like `cors.php` and `view.php` are not published by default, as most applications will never need to modify them.
-
-However, you may use the `vendor:publish` Artisan command to publish packages' assets including configuration files that are not published by default:
-
-```shell:no-line-numbers
-php artisan vendor:publish package
-
-php artisan vendor:publish --all
-```
-
-## Debug Mode
-
-The `debug` option in your `config/app.php` configuration file determines how much information about an error is actually displayed to the user. By default, this option is set to respect the value of the `APP_DEBUG` environment variable, which is stored in your `.env` file.
-
-::: warning
-For local development, you should set the `APP_DEBUG` environment variable to `true`. **In your production environment, this value should always be `false`. If the variable is set to `true` in production, you risk exposing sensitive configuration values to your application's end users.**
-:::
diff --git a/_archive/docs/0.3/docs/console-tests.md b/_archive/docs/0.3/docs/console-tests.md
deleted file mode 100644
index 48bf7bd1c8..0000000000
--- a/_archive/docs/0.3/docs/console-tests.md
+++ /dev/null
@@ -1,140 +0,0 @@
-# Console Tests
-[[toc]]
-
-## Introduction
-
-In addition to simplifying HTTP testing, Hypervel provides a simple API for testing your application's [custom console commands](/docs/artisan).
-
-## Success / Failure Expectations
-
-To get started, let's explore how to make assertions regarding an Artisan command's exit code. To accomplish this, we will use the `artisan` method to invoke an Artisan command from our test. Then, we will use the `assertExitCode` method to assert that the command completed with a given exit code:
-
-```php
-/**
- * Test a console command.
- */
-public function testConsoleCommand(): void
-{
- $this->artisan('inspire')->assertExitCode(0);
-}
-```
-
-You may use the `assertNotExitCode` method to assert that the command did not exit with a given exit code:
-
-```php
-$this->artisan('inspire')->assertNotExitCode(1);
-```
-
-Of course, all terminal commands typically exit with a status code of `0` when they are successful and a non-zero exit code when they are not successful. Therefore, for convenience, you may utilize the `assertSuccessful` and `assertFailed` assertions to assert that a given command exited with a successful exit code or not:
-
-```php
-$this->artisan('inspire')->assertSuccessful();
-
-$this->artisan('inspire')->assertFailed();
-```
-
-## Input / Output Expectations
-
-Hypervel allows you to easily "mock" user input for your console commands using the `expectsQuestion` method. In addition, you may specify the exit code and text that you expect to be output by the console command using the `assertExitCode` and `expectsOutput` methods. For example, consider the following console command:
-
-```php
-Artisan::command('question', function () {
- $name = $this->ask('What is your name?');
-
- $language = $this->choice('Which language do you prefer?', [
- 'PHP',
- 'Ruby',
- 'Python',
- ]);
-
- $this->line('Your name is '.$name.' and you prefer '.$language.'.');
-});
-```
-
-You may test this command with the following test:
-
-```php
-/**
- * Test a console command.
- */
-public function testConsoleCommand(): void
-{
- $this->artisan('question')
- ->expectsQuestion('What is your name?', 'Taylor Otwell')
- ->expectsQuestion('Which language do you prefer?', 'PHP')
- ->expectsOutput('Your name is Taylor Otwell and you prefer PHP.')
- ->doesntExpectOutput('Your name is Taylor Otwell and you prefer Ruby.')
- ->assertExitCode(0);
-}
-```
-
-If you are utilizing the `search` or `multisearch` functions provided by [Hypervel Prompts](/docs/prompts), you may use the `expectsSearch` assertion to mock the user's input, search results, and selection:
-
-```php
-/**
- * Test a console command.
- */
-public function test_console_command(): void
-{
- $this->artisan('example')
- ->expectsSearch('What is your name?', search: 'Tay', answers: [
- 'Taylor Otwell',
- 'Taylor Swift',
- 'Darian Taylor'
- ], answer: 'Taylor Otwell')
- ->assertExitCode(0);
-}
-```
-
-You may also assert that a console command does not generate any output using the `doesntExpectOutput` method:
-
-```php
-/**
- * Test a console command.
- */
-public function testConsoleCommand(): void
-{
- $this->artisan('example')
- ->doesntExpectOutput()
- ->assertExitCode(0);
-}
-```
-
-The `expectsOutputToContain` and `doesntExpectOutputToContain` methods may be used to make assertions against a portion of the output:
-
-```php
-/**
- * Test a console command.
- */
-public function testConsoleCommand(): void
-{
- $this->artisan('example')
- ->expectsOutputToContain('Taylor')
- ->assertExitCode(0);
-}
-```
-
-#### Confirmation Expectations
-
-When writing a command which expects confirmation in the form of a "yes" or "no" answer, you may utilize the `expectsConfirmation` method:
-
-```php
-$this->artisan('module:import')
- ->expectsConfirmation('Do you really wish to run this command?', 'no')
- ->assertExitCode(1);
-```
-
-#### Table Expectations
-
-If your command displays a table of information using Artisan's `table` method, it can be cumbersome to write output expectations for the entire table. Instead, you may use the `expectsTable` method. This method accepts the table's headers as its first argument and the table's data as its second argument:
-
-```php
-$this->artisan('users:all')
- ->expectsTable([
- 'ID',
- 'Email',
- ], [
- [1, 'taylor@example.com'],
- [2, 'abigail@example.com'],
- ]);
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/container.md b/_archive/docs/0.3/docs/container.md
deleted file mode 100644
index 945114f4a2..0000000000
--- a/_archive/docs/0.3/docs/container.md
+++ /dev/null
@@ -1,382 +0,0 @@
-# Service Container
-[[toc]]
-
-## Introduction
-
-Service container in Hyperf follows [PSR-11](https://www.php-fig.org/psr/psr-11/) and provides minimum abilities for managing service bindings. And it's designed for long-life applications and with AOP support.
-
-Based on Hyperf's container, Hypervel extends a bunch of features from Laravel's container such as alias and container events.
-
-The Hypervel service container is a powerful tool for managing class dependencies and performing dependency injection. Dependency injection is a fancy phrase that essentially means this: class dependencies are "injected" into the class via the constructor or, in some cases, "setter" methods.
-
-Let's look at a simple example:
-
-```php
- $this->apple->findPodcast($id)
- ]);
- }
-}
-```
-
-In this example, the `PodcastController` needs to retrieve podcasts from a data source such as Apple Music. So, we will **inject** a service that is able to retrieve podcasts. Since the service is injected, we are able to easily "mock", or create a dummy implementation of the `AppleMusic` service when testing our application.
-
-A deep understanding of the Hypervel service container is essential to building a powerful, large application, as well as for contributing to the Laravel core itself.
-
-### Differences between Laravel Container
-
-To ensure compatibility with the Hyperf Container, there are some important differences you need to be aware of:
-
-* Different from Laravel, every binding in the Hyperf Container is a `singleton`. You need to ensure that every instance can be shared across different requests and coroutines. **Do not store states in the objects!** Instead, use [Context](/docs/context) if you need to maintain states within objects.
-
-* If you need to get a new instance rather than fetching the same singleton object from the container, you can use the `make` function. This will initiate a new object and inject related dependencies (note that these dependencies are still singletons).
-
-* The `has` function in the Hyperf Container follows PSR-11 standards. It only determines if the target can be resolved. It will return true if the container can return an entry for the given identifier. `has($id)` returning true does not mean that `get($id)` will not throw an exception. It does, however, mean that `get($id)` will not throw a `NotFoundExceptionInterface`. You can use the `bound` method as an alternative for checking if an ID is bound to the container.
-
-::: important
-Please read the above description carefully before using the container in Hypervel!
-:::
-
-### Zero Configuration Resolution
-
-If a class has no dependencies or only depends on other concrete classes (not interfaces), the container does not need to be instructed on how to resolve that class. For example, you may place the following code in your `routes/web.php` file:
-
-```php
-app` property. We can register a binding using the `bind` method, passing the class or interface name that we wish to register along with a closure that returns an instance of the class:
-
-```php
-use App\Services\Transistor;
-use App\Services\PodcastParser;
-use Hypervel\Foundation\Contracts\Application;
-
-$this->app->bind(Transistor::class, function (Application $app) {
- return new Transistor($app->get(PodcastParser::class));
-});
-```
-
-Note that we receive the container itself as an argument to the resolver. We can then use the container to resolve sub-dependencies of the object we are building.
-
-As mentioned, you will typically be interacting with the container within service providers; however, if you would like to interact with the container outside of a service provider, you may do so via the `App` [facade](/docs/facades):
-
-```php
-use App\Services\Transistor;
-use Hypervel\Foundation\Contracts\Application;
-use Hypervel\Support\Facades\App;
-
-App::bind(Transistor::class, function (Application $app) {
- // ...
-});
-```
-
-You may use the `bindIf` method to register a container binding only if a binding has not already been registered for the given type:
-
-```php
-$this->app->bindIf(Transistor::class, function (Application $app) {
- return new Transistor($app->get(PodcastParser::class));
-});
-```
-
-::: note
-There is no need to bind classes into the container if they do not depend on any interfaces. The container does not need to be instructed on how to build these objects, since it can automatically resolve these objects using reflection.
-:::
-
-#### Binding Instances
-
-You may also bind an existing object instance into the container using the `instance` method. The given instance will always be returned on subsequent calls into the container:
-
-```php
-use App\Services\Transistor;
-use App\Services\PodcastParser;
-
-$service = new Transistor(new PodcastParser);
-
-$this->app->instance(Transistor::class, $service);
-```
-
-### Binding Interfaces to Implementations
-
-A very powerful feature of the service container is its ability to bind an interface to a given implementation. For example, let's assume we have an `EventPusher` interface and a `RedisEventPusher` implementation. Once we have coded our `RedisEventPusher` implementation of this interface, we can register it with the service container like so:
-
-```php
-use App\Contracts\EventPusher;
-use App\Services\RedisEventPusher;
-
-$this->app->bind(EventPusher::class, RedisEventPusher::class);
-```
-
-This statement tells the container that it should inject the `RedisEventPusher` when a class needs an implementation of `EventPusher`. Now we can type-hint the `EventPusher` interface in the constructor of a class that is resolved by the container. Remember, controllers, event listeners, middleware, and various other types of classes within Laravel Hyper applications are always resolved using the container:
-
-```php
-use App\Contracts\EventPusher;
-
-/**
- * Create a new class instance.
- */
-public function __construct(
- protected EventPusher $pusher
-) {}
-```
-
-### Extending Bindings
-
-The `extend` method allows the modification of resolved services. For example, when a service is resolved, you may run additional code to decorate or configure the service. The `extend` method accepts two arguments, the service class you're extending and a closure that should return the modified service. The closure receives the service being resolved and the container instance:
-
-```php
-$this->app->extend(Service::class, function (Service $service, Application $app) {
- return new DecoratedService($service);
-});
-```
-
-## Resolving
-
-### The `get` Method
-
-You may use the `get` method to resolve a class instance from the container. The `get` method accepts the name of the class or interface you wish to resolve:
-
-```php
-use App\Services\Transistor;
-
-$transistor = $this->app->get(Transistor::class);
-```
-
-::: important
-Every bindings fetched via `get` function is singleton.
-:::
-
-### The `make` Method
-
-If you want to get new instance object from the container, you may use the `make` method to resolve a class instance from the container. It's suitable for short-lived use cases.
-
-```php
-use App\Services\Transistor;
-
-$transistor = $this->app->make(Transistor::class);
-```
-
-If some of your class's dependencies are not resolvable via the container, you may inject them by passing them as an associative array into the `makeWith` method. For example, we may manually pass the `$id` constructor argument required by the `Transistor` service:
-
-```php
-use App\Services\Transistor;
-
-$transistor = $this->app->makeWith(Transistor::class, ['id' => 1]);
-```
-
-The `bound` method may be used to determine if a class or interface has been explicitly bound in the container:
-
-```php
-if ($this->app->bound(Transistor::class)) {
- // ...
-}
-```
-
-If you are outside of a service provider in a location of your code that does not have access to the `$app` variable, you may use the `App` [facade](/docs/facades) or the `app` [helper](/docs/helpers#method-app) to resolve a class instance from the container:
-
-```php
-use App\Services\Transistor;
-use Hypervel\Support\Facades\App;
-
-$transistor = App::make(Transistor::class);
-
-$transistor = app(Transistor::class);
-```
-
-If you would like to have the Hypervel container instance itself injected into a class that is being resolved by the container, you may type-hint the `Hypervel\Container\Contracts\Container` class on your class's constructor:
-
-```php
-use Hypervel\Container\Contracts\Container;
-
-/**
- * Create a new class instance.
- */
-public function __construct(
- protected Container $container
-) {}
-```
-
-::: tip
-You can get the container instance by this bindings:
-
-* `app`
-* `Psr\Container\ContainerInterface::class`
-* `Hyperf\Di\Container::class`
-* `Hyperf\Contract\ContainerInterface::class`
-* `Hypervel\Container\Contracts\Container::class`
-* `Hypervel\Container\Container::class`
-* `Hypervel\Foundation\Contracts\Application::class`
-* `Hypervel\Foundation\Application::class`
-:::
-
-### Automatic Injection
-
-Alternatively, and importantly, you may type-hint the dependency in the constructor of a class that is resolved by the container, including [controllers](/docs/controllers), [event listeners](/docs/events), [middleware](/docs/middleware), and more. In practice, this is how most of your objects should be resolved by the container.
-
-For example, you may type-hint a service defined by your application in a controller's constructor. The service will automatically be resolved and injected into the class:
-
-```php
-apple->findPodcast($id);
- }
-}
-```
-
-## Method Invocation and Injection
-
-Sometimes you may wish to invoke a method on an object instance while allowing the container to automatically inject that method's dependencies. For example, given the following class:
-
-```php
-app->resolving(Transistor::class, function (Transistor $transistor, Application $app) {
- // Called when container resolves objects of type "Transistor"...
-});
-
-$this->app->resolving(function (mixed $object, Application $app) {
- // Called when container resolves object of any type...
-});
-```
-
-As you can see, the object being resolved will be passed to the callback, allowing you to set any additional properties on the object before it is given to its consumer.
-
-## PSR-11
-
-Hypervel's service container implements the [PSR-11](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-11-container.md) interface. Therefore, you may type-hint the PSR-11 container interface to obtain an instance of the Hypervel container:
-
-```php
-use App\Services\Transistor;
-use Psr\Container\ContainerInterface;
-
-Route::get('/', function (ContainerInterface $container) {
- $service = $container->get(Transistor::class);
-
- // ...
-});
-```
-
-An exception is thrown if the given identifier can't be resolved. The exception will be an instance of `Psr\Container\NotFoundExceptionInterface` if the identifier was never bound. If the identifier was bound but was unable to be resolved, an instance of `Psr\Container\ContainerExceptionInterface` will be thrown.
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/context.md b/_archive/docs/0.3/docs/context.md
deleted file mode 100644
index e700278a8e..0000000000
--- a/_archive/docs/0.3/docs/context.md
+++ /dev/null
@@ -1,127 +0,0 @@
-# Context
-[[toc]]
-
-## Introduction
-
-Context is an important feature in Hypervel. It is used to store states within coroutines. Contexts in different coroutines are isolated, and when a coroutine terminates, its context will be destroyed automatically. You don't need to worry about memory leaks problem in context.
-
-If you're not familiar with the context management in coroutines, you can read [Isolating global variables with a coroutine context manager in Swoole](https://swoolelabs.com/blog/isolating-variables-with-coroutine-context) for more detailed information.
-
-::: important
-Do not mutate static variables in coroutines unless you know what you're doing, because static variables are shared by all coroutines. It will cause states bleeding and unpredictable bugs.
-:::
-
-## Interacting with Context
-
-### Get Context
-
-The `get` method will return the value of the key, if not exists, it will return the default value.
-
-```php
-use Hypervel\Context\Context;
-
-$foo = Context::get('foo', 'bar');
-
-$foo = Context::get('foo', 'bar', $coroutineId);
-```
-
-### Set Context
-
-The `set` method will set the value of the key, and return the value of the key.
-
-```php
-use Hypervel\Context\Context;
-
-// $foo is bar
-$foo = Context::set('foo', 'bar');
-
-$foo = Context::set('foo', 'bar', $coroutineId);
-```
-
-### Check If Context Key Exists
-
-The `has` method will return true if the key exists, otherwise false.
-
-```php
-use Hypervel\Context\Context;
-
-$exists = Context::has('foo');
-
-$exists = Context::has('foo', $coroutineId);
-```
-
-### Override Context
-
-Sometimes we need to check if a specific key exists. If the key exists, override the value of a key in the context. You may do so using the `override` method.
-
-```php
-use Hypervel\Context\Context;
-
-$request = Context::override(ServerRequestInterface::class, function (ServerRequestInterface $request) {
- return $request->withAddedHeader('foo', 'bar');
-});
-```
-
-::: note
-You can pass `coroutineId` to the third parameter to override the context in a specific coroutine.
-:::
-
-### Destroy Context
-
-The `destroy` method will delete the value of the key in coroutine context.
-
-```php
-use Hypervel\Context\Context;
-
-Context::destroy('foo');
-
-Context::destroy('foo', $coroutineId);
-```
-
-### Destroy All Context
-
-The `destroyAll` method will delete all the values in coroutine context.
-
-```php
-use Hypervel\Context\Context;
-
-Context::destroyAll('foo');
-
-Context::destroyAll('foo', $coroutineId);
-```
-
-### Get or Set Context
-
-The `getOrSet` method will return the value of the key, if not exists, it will set the value of the key and return.
-
-```php
-use Hypervel\Context\Context;
-
-$foo = Context::getOrSet('foo', 'bar');
-
-$foo = Context::getOrSet('foo', 'bar', $coroutineId);
-```
-
-### Copy Context
-
-The `copy` method will copy the context from another coroutine to the current coroutine.
-
-```php
-use Hypervel\Context\Context;
-
-Context::copy('foo', $fromCoroutineId, $onlyKeys);
-```
-
-### Copy Context From Non Coroutine Environment
-
-For compatibility,`Context` also works in non-coroutine environment. All the non-coroutine environment will share the same context copy.
-
-The `copyFromNonCoroutine` method will copy the context from non-coroutine environment to current coroutine.
-
-```php
-use Hypervel\Context\Context;
-
-Context::copy('copyFromNonCoroutine', $keys);
-
-Context::copy('copyFromNonCoroutine', $keys, $coroutineId);
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/contracts.md b/_archive/docs/0.3/docs/contracts.md
deleted file mode 100644
index 0d949cd343..0000000000
--- a/_archive/docs/0.3/docs/contracts.md
+++ /dev/null
@@ -1,137 +0,0 @@
-# Contracts
-[[toc]]
-
-## Introduction
-
-Hypervel's "contracts" are a set of interfaces that define the core services provided by the framework. For example, an `Hypervel\Auth\Contracts\Gate` contract defines the methods needed for authorizing a resource, while the `Hypervel\Hashing\Contracts\Hasher` contract defines the methods needed for generating a secure hash.
-
-All of the contracts live separately in the `Contracts` directory in their belonging packages. This provides a quick reference point for all available contracts, as well as a single, decoupled package that may be utilized when building packages that interact with Hypervel services.
-
-### Contracts vs. Facades
-
-Hypervel's [facades](/docs/facades) and helper functions provide a simple way of utilizing Hypervel's services without needing to type-hint and resolve contracts out of the service container. In most cases, each facade has an equivalent contract.
-
-Unlike facades, which do not require you to require them in your class' constructor, contracts allow you to define explicit dependencies for your classes. Some developers prefer to explicitly define their dependencies in this way and therefore prefer to use contracts, while other developers enjoy the convenience of facades. **In general, most applications can use facades without issue during development.**
-
-## When to Use Contracts
-
-The decision to use contracts or facades will come down to personal taste and the tastes of your development team. Both contracts and facades can be used to create robust, well-tested Hypervel applications. Contracts and facades are not mutually exclusive. Some parts of your applications may use facades while others depend on contracts. As long as you are keeping your class' responsibilities focused, you will notice very few practical differences between using contracts and facades.
-
-In general, most applications can use facades without issue during development. If you are building a package that integrates with multiple PHP frameworks you may wish to use the corresponding contracts to define your integration with Hypervel's services without the need to require Hypervel's concrete implementations in your package's `composer.json` file.
-
-## How to Use Contracts
-
-So, how do you get an implementation of a contract? It's actually quite simple.
-
-Many types of classes in Hypervel are resolved through the [service container](/docs/container), including controllers, event listeners, middleware and even route closures. So, to get an implementation of a contract, you can just "type-hint" the interface in the constructor of the class being resolved.
-
-For example, take a look at this event listener:
-
-```php
-
-## Contract Reference
-
-This table provides a quick reference to all of the Hypervel contracts and their equivalent facades:
-
-| Contract | References Facade |
-|--------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------|
-| [Hypervel\Auth\Contracts\Authorizable](https://github.com/hypervel/components/blob/main/src/auth/src/Contracts/Authorizable.php) | |
-| [Hypervel\Auth\Contracts\Gate](https://github.com/hypervel/components/blob/main/src/auth/src/Contracts/Gate.php) | `Gate` |
-| [Hypervel\Auth\Contracts\Authenticatable](https://github.com/hypervel/components/blob/main/src/auth/src/Contracts/Authenticatable.php) | |
-| [Hypervel\Auth\Contracts\Factory](https://github.com/hypervel/components/blob/main/src/auth/src/Contracts/FactoryContract.php) | `Auth` |
-| [Hypervel\Auth\Contracts\Guard](https://github.com/hypervel/components/blob/main/src/auth/src/Contracts/Guard.php) | `Auth::guard()` |
-| [Hypervel\Auth\Contracts\StatefulGuard](https://github.com/hypervel/components/blob/main/src/auth/src/Contracts/StatefulGuard.php) | |
-| [Hypervel\Auth\Contracts\SupportsBasicAuth](https://github.com/hypervel/components/blob/main/src/auth/src/Contracts/SupportsBasicAuth.php) | |
-| [Hypervel\Auth\Contracts\UserProvider](https://github.com/hypervel/components/blob/main/src/auth/src/Contracts/UserProvider.php) | |
-| [Hypervel\Bus\Contracts\Dispatcher](https://github.com/hypervel/components/blob/main/src/bus/src/Contracts/Dispatcher.php) | `Bus` |
-| [Hypervel\Bus\Contracts\QueuingDispatcher](https://github.com/hypervel/components/blob/main/src/bus/src/Contracts/QueuingDispatcher.php) | `Bus::dispatchToQueue()` |
-| [Hypervel\Broadcasting\Contracts\Factory](https://github.com/hypervel/components/blob/main/src/broadcasting/src/Contracts/Factory.php) | `Broadcast` |
-| [Hypervel\Broadcasting\Contracts\Broadcaster](https://github.com/hypervel/components/blob/main/src/broadcasting/src/Contracts/Broadcaster.php) | `Broadcast::connection()` |
-| [Hypervel\Broadcasting\Contracts\ShouldBroadcast](https://github.com/hypervel/components/blob/main/src/broadcasting/src/Contracts/ShouldBroadcast.php) | |
-| [Hypervel\Broadcasting\Contracts\ShouldBroadcastNow](https://github.com/hypervel/components/blob/main/src/broadcasting/src/Contracts/ShouldBroadcastNow.php) | |
-| [Hypervel\Cache\Contracts\Factory](https://github.com/hypervel/components/blob/main/src/cache/src/Contracts/Factory.php) | `Cache` |
-| [Hypervel\Cache\Contracts\Lock](https://github.com/hypervel/components/blob/main/src/cache/src/Contracts/Lock.php) | |
-| [Hypervel\Cache\Contracts\LockProvider](https://github.com/hypervel/components/blob/main/src/cache/src/Contracts/LockProvider.php) | |
-| [Hypervel\Cache\Contracts\Repository](https://github.com/hypervel/components/blob/main/src/cache/src/Contracts/Repository.php) | `Cache::driver()` |
-| [Hypervel\Cache\Contracts\Store](https://github.com/hypervel/components/blob/main/src/cache/src/Contracts/Store.php) | |
-| [Hypervel\Config\Contracts\Repository](https://github.com/hypervel/components/blob/main/src/config/src/Contracts/Repository.php) | `Config` |
-| [Hypervel\Container\Contracts\Container](https://github.com/hypervel/components/blob/main/src/container/src/Contracts/Container.php) | `App` |
-| [Hypervel\Foundation\Exceptions\Contracts\ExceptionHandler](https://github.com/hypervel/components/blob/main/src/foundation/src/Exceptions/Contracts/ExceptionHandler.php) | |
-| [Hypervel\Encryption\Contracts\Encrypter](https://github.com/hypervel/components/blob/main/src/encryption/src/Contracts/ReposEncrypteritory.php) | `Crypt` |
-| [Hypervel\Event\Contracts\Dispatcher](https://github.com/hypervel/components/blob/main/src/event/src/Contracts/Dispatcher.php) | `Event` |
-| [Hypervel\Filesystem\Contracts\Cloud](https://github.com/hypervel/components/blob/main/src/filesystem/src/Contracts/Cloud.php) | `Storage::cloud()` |
-| [Hypervel\Filesystem\Contracts\Factory](https://github.com/hypervel/components/blob/main/src/filesystem/src/Contracts/Factory.php) | `Storage` |
-| [Hypervel\Filesystem\Contracts\Filesystem](https://github.com/hypervel/components/blob/main/src/filesystem/src/Contracts/Filesystem.php) | `Storage::disk()` |
-| [Hypervel\Foundation\Contracts\Application](https://github.com/hypervel/components/blob/main/src/foundation/src/Contracts/Application.php) | `App` |
-| [Hypervel\Console\Contracts\Application](https://github.com/hypervel/components/blob/main/src/foundation/src/Console/Contracts/Application.php) | |
-| [Hypervel\Foundation\Console\Contracts\Kernel](https://github.com/hypervel/components/blob/main/src/foundation/src/Console/Contracts/Kernel.php) | `Artisan` |
-| [Hypervel\Hashing\Contracts\Hasher](https://github.com/hypervel/components/blob/main/src/hashing/src/Contracts/Hasher.php) | `Hash` |
-| [Hypervel\Mail\Contracts\MailQueue](https://github.com/hypervel/components/blob/main/src/mail/src/Contracts/MailQueue.php) | `Mail::queue()` |
-| [Hypervel\Mail\Contracts\Mailable](https://github.com/hypervel/components/blob/main/src/mail/src/Contracts/Mailable.php) | |
-| [Hypervel\Mail\Contracts\Mailer](https://github.com/hypervel/components/blob/main/src/mail/src/Contracts/Mailer.php) | `Mail` |
-| [Hypervel\Notifications\Contracts\Dispatcher](https://github.com/hypervel/components/blob/main/src/notifications/src/Contracts/Dispatcher.php) | `Notification` |
-| [Hypervel\Notifications\Contracts\Factory](https://github.com/hypervel/components/blob/main/src/notifications/src/Contracts/Factory.php) | `Notification` |
-| [Hypervel\ObjectPool\Contracts\Factory](https://github.com/hypervel/components/blob/main/src/object-pool/src/Contracts/Factory.php) | |
-| [Hypervel\ObjectPool\Contracts\ObjectPool](https://github.com/hypervel/components/blob/main/src/object-pool/src/Contracts/ObjectPool.php) | |
-| [Hypervel\ObjectPool\Contracts\Recycler](https://github.com/hypervel/components/blob/main/src/object-pool/src/Contracts/Recycler.php) | |
-| [Hypervel\Queue\Contracts\EntityResolver](https://github.com/hypervel/components/blob/main/src/queue/src/Contracts/EntityResolver.php) | |
-| [Hypervel\Queue\Contracts\Factory](https://github.com/hypervel/components/blob/main/src/queue/src/Contracts/Factory.php) | `Queue` |
-| [Hypervel\Queue\Contracts\Job](https://github.com/hypervel/components/blob/main/src/queue/src/Contracts/Job.php) | |
-| [Hypervel\Queue\Contracts\Monitor](https://github.com/hypervel/components/blob/main/src/queue/src/Contracts/Factory.php) | `Queue` |
-| [Hypervel\Queue\Contracts\Queue](https://github.com/hypervel/components/blob/main/src/queue/src/Contracts/Queue.php) | `Queue::connection()` |
-| [Hypervel\Queue\Contracts\QueueableCollection](https://github.com/hypervel/components/blob/main/src/queue/src/Contracts/QueueableCollection.php) | |
-| [Hypervel\Queue\Contracts\QueueableEntity](https://github.com/hypervel/components/blob/main/src/queue/src/Contracts/QueueableEntity.php) | |
-| [Hypervel\Queue\Contracts\ShouldQueue](https://github.com/hypervel/components/blob/main/src/queue/src/Contracts/ShouldQueue.php) | |
-| [Hypervel\Router\Contracts\UrlGenerator](https://github.com/hypervel/components/blob/main/src/router/contracts/UrlGenerator.php) | |
-| [Hypervel\Router\Contracts\UrlRoutable](https://github.com/hypervel/components/blob/main/src/router/contracts/UrlRoutable.php) | |
-| [Hypervel\Session\Contracts\Factory](https://github.com/hypervel/components/blob/main/src/session/contracts/Factory.php) | |
-| [Hypervel\Session\Contracts\Session](https://github.com/hypervel/components/blob/main/src/session/contracts/Session.php) | `Session::store()` |
-| [Hypervel\Support\Contracts\Arrayable](https://github.com/hypervel/components/blob/main/src/support/contracts/Arrayable.php) | |
-| [Hypervel\Support\Contracts\Htmlable](https://github.com/hypervel/components/blob/main/src/support/contracts/Htmlable.php) | |
-| [Hypervel\Support\Contracts\Jsonable](https://github.com/hypervel/components/blob/main/src/support/contracts/Jsonable.php) | |
-| [Hypervel\Support\Contracts\MessageBag](https://github.com/hypervel/components/blob/main/src/support/contracts/MessageBag.php) | |
-| [Hypervel\Support\Contracts\MessageProvider](https://github.com/hypervel/components/blob/main/src/support/contracts/MessageProvider.php) | |
-| [Hypervel\Support\Contracts\Renderable](https://github.com/hypervel/components/blob/main/src/support/contracts/Renderable.php) | |
-| [Hypervel\Support\Contracts\Reasonable](https://github.com/hypervel/components/blob/main/src/support/contracts/Reasonable.php) | |
-| [Hypervel\Translation\Contracts\Loader](https://github.com/hypervel/components/blob/main/src/translation/contracts/Loader.php) | |
-| [Hypervel\Translation\Contracts\Translator](https://github.com/hypervel/components/blob/main/src/translation/contracts/Translator.php) | `Lang` |
-| [Hypervel\Foundation\Exceptions\Contracts\ExceptionHandler](https://github.com/hypervel/components/blob/main/src/foundation/src/Exceptions/Contracts/ExceptionHandler.php) | |
-| [Hypervel\Foundation\Exceptions\Contracts\ExceptionRenderer](https://github.com/hypervel/components/blob/main/src/foundation/src/Exceptions/Contracts/ExceptionRenderer.php) | |
-| [Hypervel\Foundation\Http\Contracts\ExceptionRenderer](https://github.com/hypervel/components/blob/main/src/foundation/src/Http/Contracts/MiddlewareContract.php) | |
-| [Hypervel\Cookie\Contracts\Cookie](https://github.com/hypervel/components/blob/main/src/cookie/src/Contracts/Cookie.php) | `Cookie` |
-| [Hypervel\Http\Contracts\RequestContract](https://github.com/hypervel/components/blob/main/src/http/src/Contracts/RequestContract.php) | `Request` |
-| [Hypervel\Http\Contracts\ResponseContract](https://github.com/hypervel/components/blob/main/src/http/src/Contracts/ResponseContract.php) | `Response` |
-| [Hypervel\Router\Contracts\UrlGenerator](https://github.com/hypervel/components/blob/main/src/router/src/Contracts/UrlGenerator.php) | `URL` |
-
-::: info
-The contracts in Hyperf can refer to [hyperf/contract](https://github.com/hyperf/hyperf/tree/master/src/contract/src) package
-:::
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/contributions.md b/_archive/docs/0.3/docs/contributions.md
deleted file mode 100644
index d53001af47..0000000000
--- a/_archive/docs/0.3/docs/contributions.md
+++ /dev/null
@@ -1,86 +0,0 @@
-# Contribution Guide
-[[toc]]
-
-## Bug Reports
-
-To encourage active collaboration, Hypervel strongly encourages pull requests, not just bug reports. Pull requests will only be reviewed when marked as "ready for review" (not in the "draft" state) and all tests for new features are passing. Lingering, non-active pull requests left in the "draft" state will be closed after a few days.
-
-However, if you file a bug report, your issue should contain a title and a clear description of the issue. You should also include as much relevant information as possible and a code sample that demonstrates the issue. The goal of a bug report is to make it easy for yourself - and others - to replicate the bug and develop a fix.
-
-Remember, bug reports are created in the hope that others with the same problem will be able to collaborate with you on solving it. Do not expect that the bug report will automatically see any activity or that others will jump to fix it. Creating a bug report serves to help yourself and others start on the path of fixing the problem. If you want to chip in, you can help out by fixing [any bugs listed in our issue trackers](https://github.com/hypervel/components/issues). You must be authenticated with GitHub to view all of Hypervel's issues.
-
-If you notice improper DocBlock, PHPStan, or IDE warnings while using Hypervel, do not create a GitHub issue. Instead, please submit a pull request to fix the problem.
-
-## Support Questions
-
-Hypervel's GitHub issue trackers are not intended to provide Hypervel help or support. Instead, use [GitHub Discussions](https://github.com/hypervel/components/discussions)
-
-## Which Branch?
-
-All bug fixes should be sent to the latest version that supports bug fixes (currently **0.1**). Bug fixes should never be sent to the **main** branch unless they fix features that exist only in the upcoming release.
-
-**Minor** features that are **fully backward compatible** with the current release may be sent to the latest stable branch (currently 0.1).
-
-**Major new** features or features with breaking changes should always be sent to the **main** branch, which contains the upcoming release.
-
-## Security Vulnerabilities
-
-If you discover a security vulnerability within Hypervel, please send an email to Albert Chen at [albert@hypervel.org](mailto:albert@hypervel.org). All security vulnerabilities will be promptly addressed.
-
-## Coding Style
-
-Hypervel follows the [PSR-12](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-12-extended-coding-style-guide-meta.md) coding standard and the [PSR-4](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md) autoloading standard.
-
-### Strict Types
-
-Always use native types for type hinting, and declare strict types at the beginning of PHP files.
-
-```php
-declare(strict_types=1);
-
-/**
- * Execute the job.
- */
-public function handle(AudioProcessor $processor): void
-{
- //
-}
-```
-
-### PHPDoc
-
-Below is an example of a valid Hypervel documentation block if you need to mark additional info for the type hinting. Note that the `@param` attribute is followed by two spaces, the argument type, two more spaces, and finally the variable name:
-
-```php
-/**
- * E-mail the results of the scheduled operation if it fails.
- *
- * @param array|mixed $addresses
- */
-public function emailOutputOnFailure(mixed $addresses): static
-```
-
-And when the native type is generic, please specify the generic type through the use of the `@param` or `@return` attributes:
-
-```php
-/**
- * Get the attachments for the message.
- *
- * @return array
-
-- MariaDB 10.3+ ([Version Policy](https://mariadb.org/about/#maintenance-policy))
-- MySQL 5.7+ ([Version Policy](https://en.wikipedia.org/wiki/MySQL#Release_history))
-- PostgreSQL 10.0+ ([Version Policy](https://www.postgresql.org/support/versioning/))
-- SQLite 3.26.0+
-- SQL Server 2017+ ([Version Policy](https://docs.microsoft.com/en-us/lifecycle/products/?products=sql-server))
-
-
-
-::: info
-By default Hypervel Hyperf doesn't include drivers for PostgresSQL and SQL Server. You can install these drivers with `hyperf/database-pgsql` and `hyperf/database-sqlserver-incubator` manually.
-:::
-
-::: warning
-Because MongoDB extension doesn't support coroutine feature, there's no mongo driver in Hypervel Hyperf at this moment.
-:::
-
-### Configuration
-
-The configuration for Hypervel Hyperf's database services is located in your application's `config/database.php` configuration file. In this file, you may define all of your database connections, as well as specify which connection should be used by default. Most of the configuration options within this file are driven by the values of your application's environment variables. Examples for most of Hypervel Hyperf's supported database systems are provided in this file.
-
-#### SQLite Configuration
-
-SQLite databases are contained within a single file on your filesystem. You can create a new SQLite database using the `touch` command in your terminal: `touch database/database.sqlite`. After the database has been created, you may easily configure your environment variables to point to this database by placing the absolute path to the database in the `DB_DATABASE` environment variable:
-
-```ini
-DB_CONNECTION=sqlite
-DB_DATABASE=/absolute/path/to/database.sqlite
-```
-
-By default, foreign key constraints are enabled for SQLite connections. If you would like to disable them, you should set the `DB_FOREIGN_KEYS` environment variable to `false`:
-
-```ini
-DB_FOREIGN_KEYS=false
-```
-
-::: note
-Hypervel Hyperf will automatically create a `database/database.sqlite` file and run the default [database migrations](/docs/migrations) for you when you install from composer.
-:::
-
-### Read and Write Connections
-
-Sometimes you may wish to use one database connection for SELECT statements, and another for INSERT, UPDATE, and DELETE statements. Hypervel makes this a breeze, and the proper connections will always be used whether you are using raw queries, the query builder, or the Eloquent ORM.
-
-To see how read / write connections should be configured, let's look at this example:
-
-```php
-'mysql' => [
- 'read' => [
- 'host' => [
- '192.168.1.1',
- '196.168.1.2',
- ],
- ],
- 'write' => [
- 'host' => [
- '196.168.1.3',
- ],
- ],
- 'sticky' => true,
-
- 'database' => env('DB_DATABASE', 'laravel'),
- 'username' => env('DB_USERNAME', 'root'),
- 'password' => env('DB_PASSWORD', ''),
- 'unix_socket' => env('DB_SOCKET', ''),
- 'charset' => env('DB_CHARSET', 'utf8mb4'),
- 'collation' => env('DB_COLLATION', 'utf8mb4_unicode_ci'),
- 'prefix' => '',
- 'prefix_indexes' => true,
- 'strict' => true,
- 'engine' => null,
-],
-```
-
-Note that three keys have been added to the configuration array: `read`, `write` and `sticky`. The `read` and `write` keys have array values containing a single key: `host`. The rest of the database options for the `read` and `write` connections will be merged from the main `mysql` configuration array.
-
-You only need to place items in the `read` and `write` arrays if you wish to override the values from the main `mysql` array. So, in this case, `192.168.1.1` will be used as the host for the "read" connection, while `192.168.1.3` will be used for the "write" connection. The database credentials, prefix, character set, and all other options in the main `mysql` array will be shared across both connections. When multiple values exist in the `host` configuration array, a database host will be randomly chosen for each request.
-
-#### The `sticky` Option
-
-The `sticky` option is an *optional* value that can be used to allow the immediate reading of records that have been written to the database during the current request cycle. If the `sticky` option is enabled and a "write" operation has been performed against the database during the current request cycle, any further "read" operations will use the "write" connection. This ensures that any data written during the request cycle can be immediately read back from the database during that same request. It is up to you to decide if this is the desired behavior for your application.
-
-### Connection Pooling
-
-Hypervel implements database connection pooling to efficiently manage and reuse database connections across coroutines. Connection pooling helps improve performance by reducing the overhead of establishing new database connections for each request.
-
-```php
-'mysql' => [
- 'pool' => [
- 'min_connections' => 1,
- 'max_connections' => 10,
- 'connect_timeout' => 10.0,
- 'wait_timeout' => 3.0,
- 'heartbeat' => -1,
- 'max_idle_time' => (float) env('DB_MAX_IDLE_TIME', 60),
- ]
-],
-```
-
-Each configuration option serves a specific purpose:
-
-- `min_connections`: The minimum number of connections that will be created and maintained in the pool, ensuring a base level of available connections.
-- `max_connections`: The maximum number of connections that can be created. When all connections are in use and a new request arrives, it will wait for an available connection.
-- `connect_timeout`: The maximum time to wait while trying to establish a new database connection.
-- `wait_timeout`: The maximum time to wait for an available connection from the pool before throwing an exception.
-- `heartbeat`: The interval at which the pool checks if connections are still alive.
-- `max_idle_time`: The maximum time a connection can remain idle in the pool before being closed.
-
-The connection pool automatically handles connection lifecycle management:
-
-1. When a connection is requested, the pool first tries to reuse an existing idle connection
-2. If no idle connections are available and the pool hasn't reached `max_connections`, a new connection is created
-3. If the pool is at capacity, the request waits up to `wait_timeout` seconds for a connection to become available
-4. After use, connections are returned to the pool instead of being closed, allowing for reuse
-
-This approach significantly reduces the overhead of database operations in high-concurrency scenarios by eliminating the need to establish new connections for each request.
-
-## Running SQL Queries
-
-Once you have configured your database connection, you may run queries using the `DB` facade. The `DB` facade provides methods for each type of query: `select`, `update`, `insert`, `delete`, and `statement`.
-
-#### Running a Select Query
-
-To run a basic SELECT query, you may use the `select` method on the `DB` facade:
-
-```php
- $users]);
- }
-}
-```
-
-The first argument passed to the `select` method is the SQL query, while the second argument is any parameter bindings that need to be bound to the query. Typically, these are the values of the `where` clause constraints. Parameter binding provides protection against SQL injection.
-
-The `select` method will always return an `array` of results. Each result within the array will be a PHP `stdClass` object representing a record from the database:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-$users = DB::select('select * from users');
-
-foreach ($users as $user) {
- echo $user->name;
-}
-```
-
-#### Selecting Scalar Values
-
-Sometimes your database query may result in a single, scalar value. Instead of being required to retrieve the query's scalar result from a record object, Hypervel allows you to retrieve this value directly using the `scalar` method:
-
-```php
-$burgers = DB::scalar(
- "select count(case when food = 'burger' then 1 end) as burgers from menu"
-);
-```
-
-#### Using Named Bindings
-
-Instead of using `?` to represent your parameter bindings, you may execute a query using named bindings:
-
-```php
-$results = DB::select('select * from users where id = :id', ['id' => 1]);
-```
-
-#### Running an Insert Statement
-
-To execute an `insert` statement, you may use the `insert` method on the `DB` facade. Like `select`, this method accepts the SQL query as its first argument and bindings as its second argument:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-DB::insert('insert into users (id, name) values (?, ?)', [1, 'Marc']);
-```
-
-#### Running an Update Statement
-
-The `update` method should be used to update existing records in the database. The number of rows affected by the statement is returned by the method:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-$affected = DB::update(
- 'update users set votes = 100 where name = ?',
- ['Anita']
-);
-```
-
-#### Running a Delete Statement
-
-The `delete` method should be used to delete records from the database. Like `update`, the number of rows affected will be returned by the method:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-$deleted = DB::delete('delete from users');
-```
-
-#### Running a General Statement
-
-Some database statements do not return any value. For these types of operations, you may use the `statement` method on the `DB` facade:
-
-```php
-DB::statement('drop table users');
-```
-
-#### Running an Unprepared Statement
-
-Sometimes you may want to execute an SQL statement without binding any values. You may use the `DB` facade's `unprepared` method to accomplish this:
-
-```php
-DB::unprepared('update users set votes = 100 where name = "Dries"');
-```
-
-::: warning
-Since unprepared statements do not bind parameters, they may be vulnerable to SQL injection. You should never allow user controlled values within an unprepared statement.
-:::
-
-#### Implicit Commits
-
-When using the `DB` facade's `statement` and `unprepared` methods within transactions you must be careful to avoid statements that cause [implicit commits](https://dev.mysql.com/doc/refman/8.0/en/implicit-commit.html). These statements will cause the database engine to indirectly commit the entire transaction, leaving Hypervel unaware of the database's transaction level. An example of such a statement is creating a database table:
-
-```php
-DB::unprepared('create table a (col varchar(1) null)');
-```
-
-Please refer to the MySQL manual for [a list of all statements](https://dev.mysql.com/doc/refman/8.0/en/implicit-commit.html) that trigger implicit commits.
-
-### Using Multiple Database Connections
-
-If your application defines multiple connections in your `config/database.php` configuration file, you may access each connection via the `connection` method provided by the `DB` facade. The connection name passed to the `connection` method should correspond to one of the connections listed in your `config/database.php` configuration file or configured at runtime using the `config` helper:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-$users = DB::connection('sqlite')->select(/* ... */);
-```
-
-You may access the raw, underlying PDO instance of a connection using the `getPdo` method on a connection instance:
-
-```php
-$pdo = DB::connection()->getPdo();
-```
-
-### Listening for Query Events
-
-If you would like to specify a closure that is invoked for each SQL query executed by your application, you may use the `DB` facade's `listen` method. This method can be useful for logging queries or debugging. You may register your query listener closure in the `boot` method of a [service provider](/docs/providers):
-
-```php
-sql;
- // $query->bindings;
- // $query->time;
- });
- }
-}
-```
-
-## Database Transactions
-
-You may use the `transaction` method provided by the `DB` facade to run a set of operations within a database transaction. If an exception is thrown within the transaction closure, the transaction will automatically be rolled back and the exception is re-thrown. If the closure executes successfully, the transaction will automatically be committed. You don't need to worry about manually rolling back or committing while using the `transaction` method:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-DB::transaction(function () {
- DB::update('update users set votes = 1');
-
- DB::delete('delete from posts');
-});
-```
-
-#### Handling Deadlocks
-
-The `transaction` method accepts an optional second argument which defines the number of times a transaction should be retried when a deadlock occurs. Once these attempts have been exhausted, an exception will be thrown:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-DB::transaction(function () {
- DB::update('update users set votes = 1');
-
- DB::delete('delete from posts');
-}, 5);
-```
-
-#### Manually Using Transactions
-
-If you would like to begin a transaction manually and have complete control over rollbacks and commits, you may use the `beginTransaction` method provided by the `DB` facade:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-DB::beginTransaction();
-```
-
-You can rollback the transaction via the `rollBack` method:
-
-```php
-DB::rollBack();
-```
-
-Lastly, you can commit a transaction via the `commit` method:
-
-```php
-DB::commit();
-```
-
-::: note
-The `DB` facade's transaction methods control the transactions for both the [query builder](/docs/queries) and [Eloquent ORM](/docs/eloquent).
-:::
diff --git a/_archive/docs/0.3/docs/deployment.md b/_archive/docs/0.3/docs/deployment.md
deleted file mode 100644
index 931e2b6e36..0000000000
--- a/_archive/docs/0.3/docs/deployment.md
+++ /dev/null
@@ -1,80 +0,0 @@
-# Deployment
-[[toc]]
-
-## Introduction
-
-When you're ready to deploy your Hypervel application to production, there are some important things you can do to make sure your application is running as efficiently as possible. In this document, we'll cover some great starting points for making sure your Hypervel application is deployed properly.
-
-## Server Requirements
-
-Hypervel has a few system requirements. You should ensure that your web server has the following minimum PHP version and extensions:
-
- - PHP >= 8.2
- - [Swoole PHP extension](https://github.com/swoole/swoole-src) >= 5.1
- - JSON PHP extension
- - PDO PHP extension
- - Pcntl PHP extension
- - Session extension (If you need to use session)
- - OpenSSL PHP extension (If you need to use the HTTPS)
- - Redis PHP extension (If you need to use the Redis Client)
-
-### Docker
-
-If you plan to deploy your application via docker, you can find various Dockerfiles in the [hyperf/hyperf-docker](https://github.com/hyperf/hyperf-docker) project, or use a pre-built image based on [hyperf/hyperf](https://hub.docker.com/r/hyperf/hyperf).
-
-## Server Configuration
-
-### Nginx for HTTP
-
-If you are deploying your application to a server that is running Nginx, you may use the following configuration file as a starting point for configuring your web server. Most likely, this file will need to be customized depending on your server's configuration.
-
-```nginx
-server {
- # listening port
- listen 80;
- # Bound domain name, fill in your domain name
- server_name proxy.hypervel.org;
-
- location / {
- # Forward the client's Host and IP information to the corresponding node
- proxy_set_header Host $http_host;
- proxy_set_header X-Real-IP $remote_addr;
- proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-
- # Forward cookies, set SameSite
- proxy_cookie_path / "/; secure; HttpOnly; SameSite=strict";
-
- # Execute proxy access to real server
- proxy_pass http://127.0.0.1:9501;
- }
-}
-```
-
-### Nginx for Websocket
-
-If you plan to proxy your websocket services, you may use the following configuration file.
-
-```nginx
-server {
- listen 80;
- server_name websocket.hypervel.org;
-
- location / {
- # WebSocket Header
- proxy_http_version 1.1;
- proxy_set_header Upgrade websocket;
- proxy_set_header Connection "Upgrade";
-
- # Forward the client's Host and IP information to the corresponding node
- proxy_set_header X-Real-IP $remote_addr;
- proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
- proxy_set_header Host $http_host;
-
- # The connection between the client and the server is automatically disconnected after 60s of no interaction, please set according to the actual business scenario
- proxy_read_timeout 60s ;
-
- # Execute proxy access to real server
- proxy_pass http://127.0.0.1:9502;
- }
-}
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/eloquent-collections.md b/_archive/docs/0.3/docs/eloquent-collections.md
deleted file mode 100644
index 2a73ae2054..0000000000
--- a/_archive/docs/0.3/docs/eloquent-collections.md
+++ /dev/null
@@ -1,251 +0,0 @@
-# Eloquent: Collections
-[[toc]]
-
-## Introduction
-
-All Eloquent methods that return more than one model result will return instances of the `Hypervel\Database\Eloquent` class, including results retrieved via the `get` method or accessed via a relationship. The Eloquent collection object extends Hypervel's [base collection](/docs/collections), so it naturally inherits dozens of methods used to fluently work with the underlying array of Eloquent models. Be sure to review the Hypervel collection documentation to learn all about these helpful methods!
-
-All collections also serve as iterators, allowing you to loop over them as if they were simple PHP arrays:
-
-```php
-use App\Models\User;
-
-$users = User::where('active', 1)->get();
-
-foreach ($users as $user) {
- echo $user->name;
-}
-```
-
-However, as previously mentioned, collections are much more powerful than arrays and expose a variety of map / reduce operations that may be chained using an intuitive interface. For example, we may remove all inactive models and then gather the first name for each remaining user:
-
-```php
-$names = User::all()->reject(function ($user) {
- return $user->active === false;
-})->map(function ($user) {
- return $user->name;
-});
-```
-
-#### Eloquent Collection Conversion
-
-While most Eloquent collection methods return a new instance of an Eloquent collection, the `collapse`, `flatten`, `flip`, `keys`, `pluck`, and `zip` methods return a [base collection](/docs/collections) instance. Likewise, if a `map` operation returns a collection that does not contain any Eloquent models, it will be converted to a base collection instance.
-
-## Available Methods
-
-All Eloquent collections extend the base [Hypervel collection](/docs/collections#available-methods) object; therefore, they inherit all of the powerful methods provided by the base collection class.
-
-In addition, the `Hypervel\Database\Eloquent` class provides a superset of methods to aid with managing your model collections. Most methods return `Hypervel\Database\Eloquent` instances; however, some methods, like `modelKeys`, return an `Hypervel\Support\Collection` instance.
-
-
-
-
-
-[contains](#method-contains)
-[diff](#method-diff)
-[except](#method-except)
-[find](#method-find)
-[fresh](#method-fresh)
-[intersect](#method-intersect)
-[load](#method-load)
-[loadMissing](#method-loadMissing)
-[modelKeys](#method-modelKeys)
-[makeVisible](#method-makeVisible)
-[makeHidden](#method-makeHidden)
-[only](#method-only)
-[toQuery](#method-toquery)
-[unique](#method-unique)
-
-
-
-
-#### contains($key, $operator = null, $value = null)
-
-The `contains` method may be used to determine if a given model instance is contained by the collection. This method accepts a primary key or a model instance:
-
-```php
-$users->contains(1);
-
-$users->contains(User::find(1));
-```
-
-
-#### diff($items)
-
-The `diff` method returns all of the models that are not present in the given collection:
-
-```php
-use App\Models\User;
-
-$users = $users->diff(User::whereIn('id', [1, 2, 3])->get());
-```
-
-
-#### except($keys)
-
-The `except` method returns all of the models that do not have the given primary keys:
-
-```php
-$users = $users->except([1, 2, 3]);
-```
-
-
-#### find($key)
-
-The `find` method returns the model that has a primary key matching the given key. If `$key` is a model instance, `find` will attempt to return a model matching the primary key. If `$key` is an array of keys, `find` will return all models which have a primary key in the given array:
-
-```php
-$users = User::all();
-
-$user = $users->find(1);
-```
-
-
-#### fresh($with = [])
-
-The `fresh` method retrieves a fresh instance of each model in the collection from the database. In addition, any specified relationships will be eager loaded:
-
-```php
-$users = $users->fresh();
-
-$users = $users->fresh('comments');
-```
-
-
-#### intersect($items)
-
-The `intersect` method returns all of the models that are also present in the given collection:
-
-```php
-use App\Models\User;
-
-$users = $users->intersect(User::whereIn('id', [1, 2, 3])->get());
-```
-
-
-#### load($relations)
-
-The `load` method eager loads the given relationships for all models in the collection:
-
-```php
-$users->load(['comments', 'posts']);
-
-$users->load('comments.author');
-```
-
-
-#### loadMissing($relations)
-
-The `loadMissing` method eager loads the given relationships for all models in the collection if the relationships are not already loaded:
-
-```php
-$users->loadMissing(['comments', 'posts']);
-
-$users->loadMissing('comments.author');
-```
-
-
-#### modelKeys()
-
-The `modelKeys` method returns the primary keys for all models in the collection:
-
-```php
-$users->modelKeys();
-
-// [1, 2, 3, 4, 5]
-```
-
-
-#### makeVisible($attributes)
-
-The `makeVisible` method [makes attributes visible](/docs/eloquent-serialization#hiding-attributes-from-json) that are typically "hidden" on each model in the collection:
-
-```php
-$users = $users->makeVisible(['address', 'phone_number']);
-```
-
-
-#### makeHidden($attributes)
-
-The `makeHidden` method [hides attributes](/docs/eloquent-serialization#hiding-attributes-from-json) that are typically "visible" on each model in the collection:
-
-```php
-$users = $users->makeHidden(['address', 'phone_number']);
-```
-
-
-#### only($keys)
-
-The `only` method returns all of the models that have the given primary keys:
-
-```php
-$users = $users->only([1, 2, 3]);
-```
-
-
-#### toQuery()
-
-The `toQuery` method returns an Eloquent query builder instance containing a `whereIn` constraint on the collection model's primary keys:
-
-```php
-use App\Models\User;
-
-$users = User::where('status', 'VIP')->get();
-
-$users->toQuery()->update([
- 'status' => 'Administrator',
-]);
-```
-
-
-#### unique($key = null, $strict = false)
-
-The `unique` method returns all of the unique models in the collection. Any models of the same type with the same primary key as another model in the collection are removed:
-
-```php
-$users = $users->unique();
-```
-
-
-## Custom Collections
-
-If you would like to use a custom `Collection` object when interacting with a given model, you may define a `newCollection` method on your model:
-
-```php
-
- */
-class UserFactory extends Factory
-{
- /**
- * The current password being used by the factory.
- */
- protected static ?string $password;
-
- /**
- * Define the model's default state.
- *
- * @return array
-
-- [One To One](#one-to-one)
-- [One To Many](#one-to-many)
-- [Many To Many](#many-to-many)
-- [Has One Through](#has-one-through)
-- [Has Many Through](#has-many-through)
-- [One To One (Polymorphic)](#one-to-one-polymorphic-relations)
-- [One To Many (Polymorphic)](#one-to-many-polymorphic-relations)
-- [Many To Many (Polymorphic)](#many-to-many-polymorphic-relations)
-
-
-
-::: note
-Hypervel's Eloquent is a forked version in the Hyperf framework, which was derived from an early
-:::
-
-## Defining Relationships
-
-Eloquent relationships are defined as methods on your Eloquent model classes. Since, like Eloquent models themselves, relationships also serve as powerful [query builders](/docs/queries), defining relationships as methods provides powerful method chaining and querying capabilities. For example, we may chain additional constraints on this `posts` relationship:
-
-```php
-$user->posts()->where('active', 1)->get();
-```
-
-But, before diving too deep into using relationships, let's learn how to define each type.
-
-::: note
-Relationship names cannot collide with attribute names as that could lead to your model not being able to know which one to resolve.
-:::
-
-### One To One
-
-A one-to-one relationship is a very basic relation. For example, a `User` model might be associated with one `Phone`. To define this relationship, we place a `phone` method on the `User` model. The `phone` method should call the `hasOne` method and return its result:
-
-```php
-hasOne('App\Phone');
- }
-}
-```
-
-The first argument passed to the `hasOne` method is the name of the related model. Once the relationship is defined, we may retrieve the related record using Eloquent's dynamic properties. Dynamic properties allow you to access relationship methods as if they were properties defined on the model:
-
-```php
-$phone = User::find(1)->phone;
-```
-
-Eloquent determines the foreign key of the relationship based on the model name. In this case, the `Phone` model is automatically assumed to have a `user_id` foreign key. If you wish to override this convention, you may pass a second argument to the `hasOne` method:
-
-```php
-return $this->hasOne('App\Phone', 'foreign_key');
-```
-
-Additionally, Eloquent assumes that the foreign key should have a value matching the `id` (or the custom `$primaryKey`) column of the parent. In other words, Eloquent will look for the value of the user's `id` column in the `user_id` column of the `Phone` record. If you would like the relationship to use a value other than `id`, you may pass a third argument to the `hasOne` method specifying your custom key:
-
-```php
-return $this->hasOne('App\Phone', 'foreign_key', 'local_key');
-```
-
-#### Defining The Inverse Of The Relationship
-
-So, we can access the `Phone` model from our `User`. Now, let's define a relationship on the `Phone` model that will let us access the `User` that owns the phone. We can define the inverse of a `hasOne` relationship using the `belongsTo` method:
-
-```php
-belongsTo('App\User');
- }
-}
-```
-
-In the example above, Eloquent will try to match the `user_id` from the `Phone` model to an `id` on the `User` model. Eloquent determines the default foreign key name by examining the name of the relationship method and suffixing the method name with `_id`. However, if the foreign key on the `Phone` model is not `user_id`, you may pass a custom key name as the second argument to the `belongsTo` method:
-
-```php
-/**
- * Get the user that owns the phone.
- */
-public function user()
-{
- return $this->belongsTo('App\User', 'foreign_key');
-}
-```
-
-If your parent model does not use `id` as its primary key, or you wish to join the child model to a different column, you may pass a third argument to the `belongsTo` method specifying your parent table's custom key:
-
-```php
-/**
- * Get the user that owns the phone.
- */
-public function user()
-{
- return $this->belongsTo('App\User', 'foreign_key', 'other_key');
-}
-```
-
-### One To Many
-
-A one-to-many relationship is used to define relationships where a single model owns any amount of other models. For example, a blog post may have an infinite number of comments. Like all other Eloquent relationships, one-to-many relationships are defined by placing a function on your Eloquent model:
-
-```php
-hasMany('App\Comment');
- }
-}
-```
-
-Remember, Eloquent will automatically determine the proper foreign key column on the `Comment` model. By convention, Eloquent will take the "snake case" name of the owning model and suffix it with `_id`. So, for this example, Eloquent will assume the foreign key on the `Comment` model is `post_id`.
-
-Once the relationship has been defined, we can access the collection of comments by accessing the `comments` property. Remember, since Eloquent provides "dynamic properties", we can access relationship methods as if they were defined as properties on the model:
-
-```php
-$comments = App\Post::find(1)->comments;
-
-foreach ($comments as $comment) {
- //
-}
-```
-
-Since all relationships also serve as query builders, you can add further constraints to which comments are retrieved by calling the `comments` method and continuing to chain conditions onto the query:
-
-```php
-$comment = App\Post::find(1)->comments()->where('title', 'foo')->first();
-```
-
-Like the `hasOne` method, you may also override the foreign and local keys by passing additional arguments to the `hasMany` method:
-
-```php
-return $this->hasMany('App\Comment', 'foreign_key');
-
-return $this->hasMany('App\Comment', 'foreign_key', 'local_key');
-```
-
-### One To Many (Inverse)
-
-Now that we can access all of a post's comments, let's define a relationship to allow a comment to access its parent post. To define the inverse of a `hasMany` relationship, define a relationship function on the child model which calls the `belongsTo` method:
-
-```php
-belongsTo('App\Post');
- }
-}
-```
-
-Once the relationship has been defined, we can retrieve the `Post` model for a `Comment` by accessing the `post` "dynamic property":
-
-```php
-$comment = App\Comment::find(1);
-
-echo $comment->post->title;
-```
-
-In the example above, Eloquent will try to match the `post_id` from the `Comment` model to an `id` on the `Post` model. Eloquent determines the default foreign key name by examining the name of the relationship method and suffixing the method name with a `_` followed by the name of the primary key column. However, if the foreign key on the `Comment` model is not `post_id`, you may pass a custom key name as the second argument to the `belongsTo` method:
-
-```php
-/**
- * Get the post that owns the comment.
- */
-public function post()
-{
- return $this->belongsTo('App\Post', 'foreign_key');
-}
-```
-
-If your parent model does not use `id` as its primary key, or you wish to join the child model to a different column, you may pass a third argument to the `belongsTo` method specifying your parent table's custom key:
-
-```php
-/**
- * Get the post that owns the comment.
- */
-public function post()
-{
- return $this->belongsTo('App\Post', 'foreign_key', 'other_key');
-}
-```
-
-### Many To Many
-
-Many-to-many relations are slightly more complicated than `hasOne` and `hasMany` relationships. An example of such a relationship is a user with many roles, where the roles are also shared by other users. For example, many users may have the role of "Admin".
-
-#### Table Structure
-
-To define this relationship, three database tables are needed: `users`, `roles`, and `role_user`. The `role_user` table is derived from the alphabetical order of the related model names, and contains the `user_id` and `role_id` columns:
-
-```text:no-line-numbers
-users
- id - integer
- name - string
-
-roles
- id - integer
- name - string
-
-role_user
- user_id - integer
- role_id - integer
-```
-
-#### Model Structure
-
-Many-to-many relationships are defined by writing a method that returns the result of the `belongsToMany` method. For example, let's define the `roles` method on our `User` model:
-
-```php
-belongsToMany('App\Role');
- }
-}
-```
-
-Once the relationship is defined, you may access the user's roles using the `roles` dynamic property:
-
-```php
-$user = App\User::find(1);
-
-foreach ($user->roles as $role) {
- //
-}
-```
-
-Like all other relationship types, you may call the `roles` method to continue chaining query constraints onto the relationship:
-
-```php
-$roles = App\User::find(1)->roles()->orderBy('name')->get();
-```
-
-As mentioned previously, to determine the table name of the relationship's joining table, Eloquent will join the two related model names in alphabetical order. However, you are free to override this convention. You may do so by passing a second argument to the `belongsToMany` method:
-
-```php
-return $this->belongsToMany('App\Role', 'role_user');
-```
-
-In addition to customizing the name of the joining table, you may also customize the column names of the keys on the table by passing additional arguments to the `belongsToMany` method. The third argument is the foreign key name of the model on which you are defining the relationship, while the fourth argument is the foreign key name of the model that you are joining to:
-
-```php
-return $this->belongsToMany('App\Role', 'role_user', 'user_id', 'role_id');
-```
-
-#### Defining The Inverse Of The Relationship
-
-To define the inverse of a many-to-many relationship, you place another call to `belongsToMany` on your related model. To continue our user roles example, let's define the `users` method on the `Role` model:
-
-```php
-belongsToMany('App\User');
- }
-}
-```
-
-As you can see, the relationship is defined exactly the same as its `User` counterpart, with the exception of referencing the `App\User` model. Since we're reusing the `belongsToMany` method, all of the usual table and key customization options are available when defining the inverse of many-to-many relationships.
-
-#### Retrieving Intermediate Table Columns
-
-As you have already learned, working with many-to-many relations requires the presence of an intermediate table. Eloquent provides some very helpful ways of interacting with this table. For example, let's assume our `User` object has many `Role` objects that it is related to. After accessing this relationship, we may access the intermediate table using the `pivot` attribute on the models:
-
-```php
-$user = App\User::find(1);
-
-foreach ($user->roles as $role) {
- echo $role->pivot->created_at;
-}
-```
-
-Notice that each `Role` model we retrieve is automatically assigned a `pivot` attribute. This attribute contains a model representing the intermediate table, and may be used like any other Eloquent model.
-
-By default, only the model keys will be present on the `pivot` object. If your pivot table contains extra attributes, you must specify them when defining the relationship:
-
-```php
-return $this->belongsToMany('App\Role')->withPivot('column1', 'column2');
-```
-
-If you want your pivot table to have automatically maintained `created_at` and `updated_at` timestamps, use the `withTimestamps` method on the relationship definition:
-
-```php
-return $this->belongsToMany('App\Role')->withTimestamps();
-```
-
-#### Customizing The `pivot` Attribute Name
-
-As noted earlier, attributes from the intermediate table may be accessed on models using the `pivot` attribute. However, you are free to customize the name of this attribute to better reflect its purpose within your application.
-
-For example, if your application contains users that may subscribe to podcasts, you probably have a many-to-many relationship between users and podcasts. If this is the case, you may wish to rename your intermediate table accessor to `subscription` instead of `pivot`. This can be done using the `as` method when defining the relationship:
-
-```php
-return $this->belongsToMany('App\Podcast')
- ->as('subscription')
- ->withTimestamps();
-```
-
-Once this is done, you may access the intermediate table data using the customized name:
-
-```php
- $users = User::with('podcasts')->get();
-
- foreach ($users->flatMap->podcasts as $podcast) {
- echo $podcast->subscription->created_at;
- }
-```
-
-#### Filtering Relationships Via Intermediate Table Columns
-
-You can also filter the results returned by `belongsToMany` using the `wherePivot`, `wherePivotIn`, and `wherePivotNotIn` methods when defining the relationship:
-
-```php
-return $this->belongsToMany('App\Role')->wherePivot('approved', 1);
-
-return $this->belongsToMany('App\Role')->wherePivotIn('priority', [1, 2]);
-
-return $this->belongsToMany('App\Role')->wherePivotNotIn('priority', [1, 2]);
-```
-
-### Defining Custom Intermediate Table Models
-
-If you would like to define a custom model to represent the intermediate table of your relationship, you may call the `using` method when defining the relationship. Custom many-to-many pivot models should extend the `Hyperf\Database\Model\Relations\Pivot` class while custom polymorphic many-to-many pivot models should extend the `Hyperf\Database\Model\Relations\MorphPivot` class. For example, we may define a `Role` which uses a custom `RoleUser` pivot model:
-
-```php
-belongsToMany('App\User')->using('App\RoleUser');
- }
-}
-```
-
-When defining the `RoleUser` model, we will extend the `Pivot` class:
-
-```php
-belongsToMany('App\User')
- ->using('App\RoleUser')
- ->withPivot([
- 'created_by',
- 'updated_by',
- ]);
- }
-}
-```
-
-::: note
-Pivot models may not use the `SoftDeletes` trait. If you need to soft delete pivot records consider converting your pivot model to an actual Eloquent model.
-:::
-
-#### Custom Pivot Models And Incrementing IDs
-
-If you have defined a many-to-many relationship that uses a custom pivot model, and that pivot model has an auto-incrementing primary key, you should ensure your custom pivot model class defines an `incrementing` property that is set to `true`.
-
-```php
-/**
- * Indicates if the IDs are auto-incrementing.
- */
-public bool $incrementing = true;
-```
-
-### Has One Through
-
-The "has-one-through" relationship links models through a single intermediate relation.
-For example, if each supplier has one user, and each user is associated with one user history record, then the supplier model may access the user's history _through_ the user. Let's look at the database tables necessary to define this relationship:
-
-```text:no-line-numbers
-users
- id - integer
- supplier_id - integer
-
-suppliers
- id - integer
-
-history
- id - integer
- user_id - integer
-```
-
-Though the `history` table does not contain a `supplier_id` column, the `hasOneThrough` relation can provide access to the user's history to the supplier model. Now that we have examined the table structure for the relationship, let's define it on the `Supplier` model:
-
-```php
-hasOneThrough('App\History', 'App\User');
- }
-}
-```
-
-The first argument passed to the `hasOneThrough` method is the name of the final model we wish to access, while the second argument is the name of the intermediate model.
-
-Typical Eloquent foreign key conventions will be used when performing the relationship's queries. If you would like to customize the keys of the relationship, you may pass them as the third and fourth arguments to the `hasOneThrough` method. The third argument is the name of the foreign key on the intermediate model. The fourth argument is the name of the foreign key on the final model. The fifth argument is the local key, while the sixth argument is the local key of the intermediate model:
-
-```php
-class Supplier extends Model
-{
- /**
- * Get the user's history.
- */
- public function userHistory()
- {
- return $this->hasOneThrough(
- 'App\History',
- 'App\User',
- 'supplier_id', // Foreign key on users table...
- 'user_id', // Foreign key on history table...
- 'id', // Local key on suppliers table...
- 'id' // Local key on users table...
- );
- }
-}
-```
-
-### Has Many Through
-
-The "has-many-through" relationship provides a convenient shortcut for accessing distant relations via an intermediate relation. For example, a `Country` model might have many `Post` models through an intermediate `User` model. In this example, you could easily gather all blog posts for a given country. Let's look at the tables required to define this relationship:
-
-```text:no-line-numbers
-countries
- id - integer
- name - string
-
-users
- id - integer
- country_id - integer
- name - string
-
-posts
- id - integer
- user_id - integer
- title - string
-```
-
-Though `posts` does not contain a `country_id` column, the `hasManyThrough` relation provides access to a country's posts via `$country->posts`. To perform this query, Eloquent inspects the `country_id` on the intermediate `users` table. After finding the matching user IDs, they are used to query the `posts` table.
-
-Now that we have examined the table structure for the relationship, let's define it on the `Country` model:
-
-```php
-hasManyThrough('App\Post', 'App\User');
- }
-}
-```
-
-The first argument passed to the `hasManyThrough` method is the name of the final model we wish to access, while the second argument is the name of the intermediate model.
-
-Typical Eloquent foreign key conventions will be used when performing the relationship's queries. If you would like to customize the keys of the relationship, you may pass them as the third and fourth arguments to the `hasManyThrough` method. The third argument is the name of the foreign key on the intermediate model. The fourth argument is the name of the foreign key on the final model. The fifth argument is the local key, while the sixth argument is the local key of the intermediate model:
-
-```php
-class Country extends Model
-{
- public function posts()
- {
- return $this->hasManyThrough(
- 'App\Post',
- 'App\User',
- 'country_id', // Foreign key on users table...
- 'user_id', // Foreign key on posts table...
- 'id', // Local key on countries table...
- 'id' // Local key on users table...
- );
- }
-}
-```
-
-## Polymorphic Relationships
-
-A polymorphic relationship allows the target model to belong to more than one type of model using a single association.
-
-
-### One To One (Polymorphic)
-
-#### Table Structure
-
-A one-to-one polymorphic relation is similar to a simple one-to-one relation; however, the target model can belong to more than one type of model on a single association. For example, a blog `Post` and a `User` may share a polymorphic relation to an `Image` model. Using a one-to-one polymorphic relation allows you to have a single list of unique images that are used for both blog posts and user accounts. First, let's examine the table structure:
-
-```text:no-line-numbers
-posts
- id - integer
- name - string
-
-users
- id - integer
- name - string
-
-images
- id - integer
- url - string
- imageable_id - integer
- imageable_type - string
-```
-
-Take note of the `imageable_id` and `imageable_type` columns on the `images` table. The `imageable_id` column will contain the ID value of the post or user, while the `imageable_type` column will contain the class name of the parent model. The `imageable_type` column is used by Eloquent to determine which "type" of parent model to return when accessing the `imageable` relation.
-
-#### Model Structure
-
-Next, let's examine the model definitions needed to build this relationship:
-
-```php
-morphTo();
- }
-}
-
-class Post extends Model
-{
- /**
- * Get the post's image.
- */
- public function image()
- {
- return $this->morphOne('App\Image', 'imageable');
- }
-}
-
-class User extends Model
-{
- /**
- * Get the user's image.
- */
- public function image()
- {
- return $this->morphOne('App\Image', 'imageable');
- }
-}
-```
-
-#### Retrieving The Relationship
-
-Once your database table and models are defined, you may access the relationships via your models. For example, to retrieve the image for a post, we can use the `image` dynamic property:
-
-```php
-$post = App\Post::find(1);
-
-$image = $post->image;
-```
-
-You may also retrieve the parent from the polymorphic model by accessing the name of the method that performs the call to `morphTo`. In our case, that is the `imageable` method on the `Image` model. So, we will access that method as a dynamic property:
-
-```php
-$image = App\Image::find(1);
-
-$imageable = $image->imageable;
-```
-
-The `imageable` relation on the `Image` model will return either a `Post` or `User` instance, depending on which type of model owns the image.
-
-
-### One To Many (Polymorphic)
-
-#### Table Structure
-
-A one-to-many polymorphic relation is similar to a simple one-to-many relation; however, the target model can belong to more than one type of model on a single association. For example, imagine users of your application can "comment" on both posts and videos. Using polymorphic relationships, you may use a single `comments` table for both of these scenarios. First, let's examine the table structure required to build this relationship:
-
-```text:no-line-numbers
-posts
- id - integer
- title - string
- body - text
-
-videos
- id - integer
- title - string
- url - string
-
-comments
- id - integer
- body - text
- commentable_id - integer
- commentable_type - string
-```
-
-#### Model Structure
-
-Next, let's examine the model definitions needed to build this relationship:
-
-```php
-morphTo();
- }
-}
-
-class Post extends Model
-{
- /**
- * Get all of the post's comments.
- */
- public function comments()
- {
- return $this->morphMany('App\Comment', 'commentable');
- }
-}
-
-class Video extends Model
-{
- /**
- * Get all of the video's comments.
- */
- public function comments()
- {
- return $this->morphMany('App\Comment', 'commentable');
- }
-}
-```
-
-#### Retrieving The Relationship
-
-Once your database table and models are defined, you may access the relationships via your models. For example, to access all of the comments for a post, we can use the `comments` dynamic property:
-
-```php
-$post = App\Post::find(1);
-
-foreach ($post->comments as $comment) {
- //
-}
-```
-
-You may also retrieve the owner of a polymorphic relation from the polymorphic model by accessing the name of the method that performs the call to `morphTo`. In our case, that is the `commentable` method on the `Comment` model. So, we will access that method as a dynamic property:
-
-```php
-$comment = App\Comment::find(1);
-
-$commentable = $comment->commentable;
-```
-
-The `commentable` relation on the `Comment` model will return either a `Post` or `Video` instance, depending on which type of model owns the comment.
-
-
-### Many To Many (Polymorphic)
-
-#### Table Structure
-
-Many-to-many polymorphic relations are slightly more complicated than `morphOne` and `morphMany` relationships. For example, a blog `Post` and `Video` model could share a polymorphic relation to a `Tag` model. Using a many-to-many polymorphic relation allows you to have a single list of unique tags that are shared across blog posts and videos. First, let's examine the table structure:
-
-```text:no-line-numbers
-posts
- id - integer
- name - string
-
-videos
- id - integer
- name - string
-
-tags
- id - integer
- name - string
-
-taggables
- tag_id - integer
- taggable_id - integer
- taggable_type - string
-```
-
-#### Model Structure
-
-Next, we're ready to define the relationships on the model. The `Post` and `Video` models will both have a `tags` method that calls the `morphToMany` method on the base Eloquent class:
-
-```php
-morphToMany('App\Tag', 'taggable');
- }
-}
-```
-
-#### Defining The Inverse Of The Relationship
-
-Next, on the `Tag` model, you should define a method for each of its related models. So, for this example, we will define a `posts` method and a `videos` method:
-
-```php
-morphedByMany('App\Post', 'taggable');
- }
-
- /**
- * Get all of the videos that are assigned this tag.
- */
- public function videos()
- {
- return $this->morphedByMany('App\Video', 'taggable');
- }
-}
-```
-
-#### Retrieving The Relationship
-
-Once your database table and models are defined, you may access the relationships via your models. For example, to access all of the tags for a post, you can use the `tags` dynamic property:
-
-```php
-$post = App\Post::find(1);
-
-foreach ($post->tags as $tag) {
- //
-}
-```
-
-You may also retrieve the owner of a polymorphic relation from the polymorphic model by accessing the name of the method that performs the call to `morphedByMany`. In our case, that is the `posts` or `videos` methods on the `Tag` model. So, you will access those methods as dynamic properties:
-
-```php
-$tag = App\Tag::find(1);
-
-foreach ($tag->videos as $video) {
- //
-}
-```
-
-### Custom Polymorphic Types
-
-By default, Laravel will use the fully qualified class name to store the type of the related model. For instance, given the one-to-many example above where a `Comment` may belong to a `Post` or a `Video`, the default `commentable_type` would be either `App\Post` or `App\Video`, respectively. However, you may wish to decouple your database from your application's internal structure. In that case, you may define a "morph map" to instruct Eloquent to use a custom name for each model instead of the class name:
-
-```php
-use Hyperf\Database\Model\Relations\Relation;
-
-Relation::morphMap([
- 'posts' => 'App\Post',
- 'videos' => 'App\Video',
-]);
-```
-
-You may register the `morphMap` in the `boot` function of your `AppServiceProvider` or create a separate service provider if you wish.
-
-::: note
-When adding a "morph map" to your existing application, every morphable :::`*_type` column value in your database that still contains a fully-qualified
-class will need to be converted to its "map" name.
-:::
-
-## Querying Relations
-
-Since all types of Eloquent relationships are defined via methods, you may call those methods to obtain an instance of the relationship without actually executing the relationship queries. In addition, all types of Eloquent relationships also serve as [query builders](/docs/queries), allowing you to continue to chain constraints onto the relationship query before finally executing the SQL against your database.
-
-For example, imagine a blog system in which a `User` model has many associated `Post` models:
-
-```php
-hasMany('App\Post');
- }
-}
-```
-
-You may query the `posts` relationship and add additional constraints to the relationship like so:
-
-```php
-$user = App\User::find(1);
-
-$user->posts()->where('active', 1)->get();
-```
-
-You are able to use any of the [query builder](/docs/queries) methods on the relationship, so be sure to explore the query builder documentation to learn about all of the methods that are available to you.
-
-#### Chaining `orWhere` Clauses After Relationships
-
-As demonstrated in the example above, you are free to add additional constraints to relationships when querying them. However, use caution when chaining `orWhere` clauses onto a relationship, as the `orWhere` clauses will be logically grouped at the same level as the relationship constraint:
-
-```php
-$user->posts()
- ->where('active', 1)
- ->orWhere('votes', '>=', 100)
- ->get();
-
-// select * from posts
-// where user_id = ? and active = 1 or votes >= 100
-```
-
-In most situations, you likely intend to use [constraint groups](/docs/queries#parameter-grouping) to logically group the conditional checks between parentheses:
-
-```php
-use Hyperf\Database\Model\Builder;
-
-$user->posts()
- ->where(function (Builder $query) {
- return $query->where('active', 1)
- ->orWhere('votes', '>=', 100);
- })
- ->get();
-
-// select * from posts
-// where user_id = ? and (active = 1 or votes >= 100)
-```
-
-### Relationship Methods Vs. Dynamic Properties
-
-If you do not need to add additional constraints to an Eloquent relationship query, you may access the relationship as if it were a property. For example, continuing to use our `User` and `Post` example models, we may access all of a user's posts like so:
-
-```php
-$user = App\User::find(1);
-
-foreach ($user->posts as $post) {
- //
-}
-```
-
-Dynamic properties are "lazy loading", meaning they will only load their relationship data when you actually access them. Because of this, developers often use [eager loading](#eager-loading) to pre-load relationships they know will be accessed after loading the model. Eager loading provides a significant reduction in SQL queries that must be executed to load a model's relations.
-
-### Querying Relationship Existence
-
-When accessing the records for a model, you may wish to limit your results based on the existence of a relationship. For example, imagine you want to retrieve all blog posts that have at least one comment. To do so, you may pass the name of the relationship to the `has` and `orHas` methods:
-
-```php
-// Retrieve all posts that have at least one comment...
-$posts = App\Post::has('comments')->get();
-```
-
-You may also specify an operator and count to further customize the query:
-
-```php
-// Retrieve all posts that have three or more comments...
-$posts = App\Post::has('comments', '>=', 3)->get();
-```
-
-Nested `has` statements may also be constructed using "dot" notation. For example, you may retrieve all posts that have at least one comment and vote:
-
-```php
-// Retrieve posts that have at least one comment with votes...
-$posts = App\Post::has('comments.votes')->get();
-```
-
-If you need even more power, you may use the `whereHas` and `orWhereHas` methods to put "where" conditions on your `has` queries. These methods allow you to add customized constraints to a relationship constraint, such as checking the content of a comment:
-
-```php
-use Hyperf\Database\Model\Builder;
-
-// Retrieve posts with at least one comment containing words like foo%...
-$posts = App\Post::whereHas('comments', function (Builder $query) {
- $query->where('content', 'like', 'foo%');
-})->get();
-
-// Retrieve posts with at least ten comments containing words like foo%...
-$posts = App\Post::whereHas('comments', function (Builder $query) {
- $query->where('content', 'like', 'foo%');
-}, '>=', 10)->get();
-```
-
-### Querying Relationship Absence
-
-When accessing the records for a model, you may wish to limit your results based on the absence of a relationship. For example, imagine you want to retrieve all blog posts that **don't** have any comments. To do so, you may pass the name of the relationship to the `doesntHave` and `orDoesntHave` methods:
-
-```php
-$posts = App\Post::doesntHave('comments')->get();
-```
-
-If you need even more power, you may use the `whereDoesntHave` and `orWhereDoesntHave` methods to put "where" conditions on your `doesntHave` queries. These methods allows you to add customized constraints to a relationship constraint, such as checking the content of a comment:
-
-```php
-use Hyperf\Database\Model\Builder;
-
-$posts = App\Post::whereDoesntHave('comments', function (Builder $query) {
- $query->where('content', 'like', 'foo%');
-})->get();
-```
-
-You may use "dot" notation to execute a query against a nested relationship. For example, the following query will retrieve all posts with comments from authors that are not banned:
-
-```php
-use Hyperf\Database\Model\Builder;
-
-$posts = App\Post::whereDoesntHave('comments.author', function (Builder $query) {
- $query->where('banned', 0);
-})->get();
-```
-
-### Querying Polymorphic Relationships
-
-To query the existence of `MorphTo` relationships, you may use the `whereHasMorph` method and its corresponding methods:
-
-```php
-use Hyperf\Database\Model\Builder;
-
-// Retrieve comments associated to posts or videos with a title like foo%...
-$comments = App\Comment::whereHasMorph(
- 'commentable',
- ['App\Post', 'App\Video'],
- function (Builder $query) {
- $query->where('title', 'like', 'foo%');
- }
-)->get();
-
-// Retrieve comments associated to posts with a title not like foo%...
-$comments = App\Comment::whereDoesntHaveMorph(
- 'commentable',
- 'App\Post',
- function (Builder $query) {
- $query->where('title', 'like', 'foo%');
- }
-)->get();
-```
-
-You may use the `$type` parameter to add different constraints depending on the related model:
-
-```php
-use Hyperf\Database\Model\Builder;
-
-$comments = App\Comment::whereHasMorph(
- 'commentable',
- ['App\Post', 'App\Video'],
- function (Builder $query, $type) {
- $query->where('title', 'like', 'foo%');
-
- if ($type === 'App\Post') {
- $query->orWhere('content', 'like', 'foo%');
- }
- }
-)->get();
-```
-
-Instead of passing an array of possible polymorphic models, you may provide `*` as a wildcard and let Laravel retrieve all the possible polymorphic types from the database. Laravel will execute an additional query in order to perform this operation:
-
-```php
-use Hyperf\Database\Model\Builder;
-
-$comments = App\Comment::whereHasMorph('commentable', '*', function (Builder $query) {
- $query->where('title', 'like', 'foo%');
-})->get();
-```
-
-### Counting Related Models
-
-If you want to count the number of results from a relationship without actually loading them you may use the `withCount` method, which will place a `{relation}_count` column on your resulting models. For example:
-
-```php
-$posts = App\Post::withCount('comments')->get();
-
-foreach ($posts as $post) {
- echo $post->comments_count;
-}
-```
-
-You may add the "counts" for multiple relations as well as add constraints to the queries:
-
-```php
-use Hyperf\Database\Model\Builder;
-
-$posts = App\Post::withCount(['votes', 'comments' => function (Builder $query) {
- $query->where('content', 'like', 'foo%');
-}])->get();
-
-echo $posts[0]->votes_count;
-echo $posts[0]->comments_count;
-```
-
-You may also alias the relationship count result, allowing multiple counts on the same relationship:
-
-```php
-use Hyperf\Database\Model\Builder;
-
-$posts = App\Post::withCount([
- 'comments',
- 'comments as pending_comments_count' => function (Builder $query) {
- $query->where('approved', false);
- },
-])->get();
-
-echo $posts[0]->comments_count;
-
-echo $posts[0]->pending_comments_count;
-```
-
-If you're combining `withCount` with a `select` statement, ensure that you call `withCount` after the `select` method:
-
-```php
-$posts = App\Post::select(['title', 'body'])->withCount('comments')->get();
-
-echo $posts[0]->title;
-echo $posts[0]->body;
-echo $posts[0]->comments_count;
-```
-
-In addition, using the `loadCount` method, you may load a relationship count after the parent model has already been retrieved:
-
-```php
-$book = App\Book::first();
-
-$book->loadCount('genres');
-```
-
-If you need to set additional query constraints on the eager loading query, you may pass an array keyed by the relationships you wish to load. The array values should be `Closure` instances which receive the query builder instance:
-
-```php
-$book->loadCount(['reviews' => function ($query) {
- $query->where('rating', 5);
-}])
-```
-
-## Eager Loading
-
-When accessing Eloquent relationships as properties, the relationship data is "lazy loaded". This means the relationship data is not actually loaded until you first access the property. However, Eloquent can "eager load" relationships at the time you query the parent model. Eager loading alleviates the N + 1 query problem. To illustrate the N + 1 query problem, consider a `Book` model that is related to `Author`:
-
-```php
-belongsTo('App\Author');
- }
-}
-```
-
-Now, let's retrieve all books and their authors:
-
-```php
-$books = App\Book::all();
-
-foreach ($books as $book) {
- echo $book->author->name;
-}
-```
-
-This loop will execute 1 query to retrieve all of the books on the table, then another query for each book to retrieve the author. So, if we have 25 books, this loop would run 26 queries: 1 for the original book, and 25 additional queries to retrieve the author of each book.
-
-Thankfully, we can use eager loading to reduce this operation to just 2 queries. When querying, you may specify which relationships should be eager loaded using the `with` method:
-
-```php
-$books = App\Book::with('author')->get();
-
-foreach ($books as $book) {
- echo $book->author->name;
-}
-```
-
-For this operation, only two queries will be executed:
-
-```text:no-line-numbers
-select * from books
-
-select * from authors where id in (1, 2, 3, 4, 5, ...)
-```
-
-#### Eager Loading Multiple Relationships
-
-Sometimes you may need to eager load several different relationships in a single operation. To do so, just pass additional arguments to the `with` method:
-
-```php
-$books = App\Book::with(['author', 'publisher'])->get();
-```
-
-#### Nested Eager Loading
-
-To eager load nested relationships, you may use "dot" syntax. For example, let's eager load all of the book's authors and all of the author's personal contacts in one Eloquent statement:
-
-```php
-$books = App\Book::with('author.contacts')->get();
-```
-
-#### Nested Eager Loading `morphTo` Relationships
-
-If you would like to eager load a `morphTo` relationship, as well as nested relationships on the various entities that may be returned by that relationship, you may use the `with` method in combination with the `morphTo` relationship's `morphWith` method. To help illustrate this method, let's consider the following model:
-
-```php
-morphTo();
- }
-}
-```
-
-In this example, let's assume `Event`, `Photo`, and `Post` models may create `ActivityFeed` models. Additionally, let's assume that `Event` models belong to a `Calendar` model, `Photo` models are associated with `Tag` models, and `Post` models belong to an `Author` model.
-
-Using these model definitions and relationships, we may retrieve `ActivityFeed` model instances and eager load all `parentable` models and their respective nested relationships:
-
-```php
-use Hyperf\Database\Model\Relations\MorphTo;
-
-$activities = ActivityFeed::query()
- ->with(['parentable' => function (MorphTo $morphTo) {
- $morphTo->morphWith([
- Event::class => ['calendar'],
- Photo::class => ['tags'],
- Post::class => ['author'],
- ]);
- }])->get();
-```
-
-#### Eager Loading Specific Columns
-
-You may not always need every column from the relationships you are retrieving. For this reason, Eloquent allows you to specify which columns of the relationship you would like to retrieve:
-
-```php
-$books = App\Book::with('author:id,name')->get();
-```
-
-::: note
-When using this feature, you should always include the `id` column and any relevant foreign key columns in the list of columns you wish to retrieve.
-:::
-
-#### Eager Loading By Default
-
-Sometimes you might want to always load some relationships when retrieving a model. To accomplish this, you may define a `$with` property on the model:
-
-```php
-belongsTo('App\Author');
- }
-}
-```
-
-If you would like to remove an item from the `$with` property for a single query, you may use the `without` method:
-
-```php
-$books = App\Book::without('author')->get();
-```
-
-### Constraining Eager Loads
-
-Sometimes you may wish to eager load a relationship, but also specify additional query conditions for the eager loading query. Here's an example:
-
-```php
-$users = App\User::with(['posts' => function ($query) {
- $query->where('title', 'like', '%first%');
-}])->get();
-```
-
-In this example, Eloquent will only eager load posts where the post's `title` column contains the word `first`. You may call other [query builder](/docs/queries) methods to further customize the eager loading operation:
-
-```php
-$users = App\User::with(['posts' => function ($query) {
- $query->orderBy('created_at', 'desc');
-}])->get();
-```
-
-::: note
-The `limit` and `take` query builder methods may not be used when constraining eager loads.
-:::
-
-### Lazy Eager Loading
-
-Sometimes you may need to eager load a relationship after the parent model has already been retrieved. For example, this may be useful if you need to dynamically decide whether to load related models:
-
-```php
-$books = App\Book::all();
-
-if ($someCondition) {
- $books->load('author', 'publisher');
-}
-```
-
-If you need to set additional query constraints on the eager loading query, you may pass an array keyed by the relationships you wish to load. The array values should be `Closure` instances which receive the query instance:
-
-```php
-$author->load(['books' => function ($query) {
- $query->orderBy('published_date', 'asc');
-}]);
-```
-
-To load a relationship only when it has not already been loaded, use the `loadMissing` method:
-
-```php
-public function format(Book $book)
-{
- $book->loadMissing('author');
-
- return [
- 'name' => $book->name,
- 'author' => $book->author->name,
- ];
-}
-```
-
-#### Nested Lazy Eager Loading & `morphTo`
-
-If you would like to eager load a `morphTo` relationship, as well as nested relationships on the various entities that may be returned by that relationship, you may use the `loadMorph` method.
-
-This method accepts the name of the `morphTo` relationship as its first argument, and an array of model / relationship pairs as its second argument. To help illustrate this method, let's consider the following model:
-
-```php
-morphTo();
- }
-}
-```
-
-In this example, let's assume `Event`, `Photo`, and `Post` models may create `ActivityFeed` models. Additionally, let's assume that `Event` models belong to a `Calendar` model, `Photo` models are associated with `Tag` models, and `Post` models belong to an `Author` model.
-
-Using these model definitions and relationships, we may retrieve `ActivityFeed` model instances and eager load all `parentable` models and their respective nested relationships:
-
-```php
-$activities = ActivityFeed::with('parentable')
- ->get()
- ->loadMorph('parentable', [
- Event::class => ['calendar'],
- Photo::class => ['tags'],
- Post::class => ['author'],
- ]);
-```
-
-## Inserting & Updating Related Models
-
-### The Save Method
-
-Eloquent provides convenient methods for adding new models to relationships. For example, perhaps you need to insert a new `Comment` for a `Post` model. Instead of manually setting the `post_id` attribute on the `Comment`, you may insert the `Comment` directly from the relationship's `save` method:
-
-```php
-$comment = new App\Comment(['message' => 'A new comment.']);
-
-$post = App\Post::find(1);
-
-$post->comments()->save($comment);
-```
-
-Notice that we did not access the `comments` relationship as a dynamic property. Instead, we called the `comments` method to obtain an instance of the relationship. The `save` method will automatically add the appropriate `post_id` value to the new `Comment` model.
-
-If you need to save multiple related models, you may use the `saveMany` method:
-
-```php
-$post = App\Post::find(1);
-
-$post->comments()->saveMany([
- new App\Comment(['message' => 'A new comment.']),
- new App\Comment(['message' => 'Another comment.']),
-]);
-```
-
-#### Recursively Saving Models & Relationships
-
-If you would like to `save` your model and all of its associated relationships, you may use the `push` method:
-
-```php
-$post = App\Post::find(1);
-
-$post->comments[0]->message = 'Message';
-$post->comments[0]->author->name = 'Author Name';
-
-$post->push();
-```
-
-### The Create Method
-
-In addition to the `save` and `saveMany` methods, you may also use the `create` method, which accepts an array of attributes, creates a model, and inserts it into the database. Again, the difference between `save` and `create` is that `save` accepts a full Eloquent model instance while `create` accepts a plain PHP `array`:
-
-```php
-$post = App\Post::find(1);
-
-$comment = $post->comments()->create([
- 'message' => 'A new comment.',
-]);
-```
-
-::: tip
-Before using the `create` method, be sure to review the documentation on attribute [mass assignment](/docs/eloquent#mass-assignment).
-:::
-
-You may use the `createMany` method to create multiple related models:
-
-```php
-$post = App\Post::find(1);
-
-$post->comments()->createMany([
- [
- 'message' => 'A new comment.',
- ],
- [
- 'message' => 'Another new comment.',
- ],
-]);
-```
-
-You may also use the `findOrNew`, `firstOrNew`, `firstOrCreate` and `updateOrCreate` methods to [create and update models on relationships](https://laravel.com/docs/eloquent#other-creation-methods).
-
-### Belongs To Relationships
-
-When updating a `belongsTo` relationship, you may use the `associate` method. This method will set the foreign key on the child model:
-
-```php
-$account = App\Account::find(10);
-
-$user->account()->associate($account);
-
-$user->save();
-```
-
-When removing a `belongsTo` relationship, you may use the `dissociate` method. This method will set the relationship's foreign key to `null`:
-
-```php
-$user->account()->dissociate();
-
-$user->save();
-```
-
-#### Default Models
-
-The `belongsTo`, `hasOne`, `hasOneThrough`, and `morphOne` relationships allow you to define a default model that will be returned if the given relationship is `null`. This pattern is often referred to as the [Null Object pattern](https://en.wikipedia.org/wiki/Null_Object_pattern) and can help remove conditional checks in your code. In the following example, the `user` relation will return an empty `App\User` model if no `user` is attached to the post:
-
-```php
-/**
- * Get the author of the post.
- */
-public function user()
-{
- return $this->belongsTo('App\User')->withDefault();
-}
-```
-
-To populate the default model with attributes, you may pass an array or Closure to the `withDefault` method:
-
-```php
-/**
- * Get the author of the post.
- */
-public function user()
-{
- return $this->belongsTo('App\User')->withDefault([
- 'name' => 'Guest Author',
- ]);
-}
-
-/**
- * Get the author of the post.
- */
-public function user()
-{
- return $this->belongsTo('App\User')->withDefault(function ($user, $post) {
- $user->name = 'Guest Author';
- });
-}
-```
-
-### Many To Many Relationships
-
-#### Attaching / Detaching
-
-Eloquent also provides a few additional helper methods to make working with related models more convenient. For example, let's imagine a user can have many roles and a role can have many users. To attach a role to a user by inserting a record in the intermediate table that joins the models, use the `attach` method:
-
-```php
-$user = App\User::find(1);
-
-$user->roles()->attach($roleId);
-```
-
-When attaching a relationship to a model, you may also pass an array of additional data to be inserted into the intermediate table:
-
-```php
-$user->roles()->attach($roleId, ['expires' => $expires]);
-```
-
-Sometimes it may be necessary to remove a role from a user. To remove a many-to-many relationship record, use the `detach` method. The `detach` method will delete the appropriate record out of the intermediate table; however, both models will remain in the database:
-
-```php
-// Detach a single role from the user...
-$user->roles()->detach($roleId);
-
-// Detach all roles from the user...
-$user->roles()->detach();
-```
-
-For convenience, `attach` and `detach` also accept arrays of IDs as input:
-
-```php
-$user = App\User::find(1);
-
-$user->roles()->detach([1, 2, 3]);
-
-$user->roles()->attach([
- 1 => ['expires' => $expires],
- 2 => ['expires' => $expires],
-]);
-```
-
-#### Syncing Associations
-
-You may also use the `sync` method to construct many-to-many associations. The `sync` method accepts an array of IDs to place on the intermediate table. Any IDs that are not in the given array will be removed from the intermediate table. So, after this operation is complete, only the IDs in the given array will exist in the intermediate table:
-
-```php
-$user->roles()->sync([1, 2, 3]);
-```
-
-You may also pass additional intermediate table values with the IDs:
-
-```php
-$user->roles()->sync([1 => ['expires' => true], 2, 3]);
-```
-
-If you do not want to detach existing IDs, you may use the `syncWithoutDetaching` method:
-
-```php
-$user->roles()->syncWithoutDetaching([1, 2, 3]);
-```
-
-#### Toggling Associations
-
-The many-to-many relationship also provides a `toggle` method which "toggles" the attachment status of the given IDs. If the given ID is currently attached, it will be detached. Likewise, if it is currently detached, it will be attached:
-
-```php
-$user->roles()->toggle([1, 2, 3]);
-```
-
-#### Saving Additional Data On A Pivot Table
-
-When working with a many-to-many relationship, the `save` method accepts an array of additional intermediate table attributes as its second argument:
-
-```php
-App\User::find(1)->roles()->save($role, ['expires' => $expires]);
-```
-
-#### Updating A Record On A Pivot Table
-
-If you need to update an existing row in your pivot table, you may use `updateExistingPivot` method. This method accepts the pivot record foreign key and an array of attributes to update:
-
-```php
-$user = App\User::find(1);
-
-$user->roles()->updateExistingPivot($roleId, $attributes);
-```
-
-## Touching Parent Timestamps
-
-When a model `belongsTo` or `belongsToMany` another model, such as a `Comment` which belongs to a `Post`, it is sometimes helpful to update the parent's timestamp when the child model is updated. For example, when a `Comment` model is updated, you may want to automatically "touch" the `updated_at` timestamp of the owning `Post`. Eloquent makes it easy. Just add a `touches` property containing the names of the relationships to the child model:
-
-```php
-belongsTo('App\Post');
- }
-}
-```
-
-Now, when you update a `Comment`, the owning `Post` will have its `updated_at` column updated as well, making it more convenient to know when to invalidate a cache of the `Post` model:
-
-```php
-$comment = App\Comment::find(1);
-
-$comment->text = 'Edit to this comment!';
-
-$comment->save();
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/eloquent-resources.md b/_archive/docs/0.3/docs/eloquent-resources.md
deleted file mode 100644
index 56502df126..0000000000
--- a/_archive/docs/0.3/docs/eloquent-resources.md
+++ /dev/null
@@ -1,703 +0,0 @@
-# Eloquent: API Resources
-[[toc]]
-
-## Introduction
-
-When building an API, you may need a transformation layer that sits between your Eloquent models and the JSON responses that are actually returned to your application's users. Hypervel's resource classes allow you to expressively and easily transform your models and model collections into JSON.
-
-## Generating Resources
-
-To generate a resource class, you may use the `make:resource` Artisan command. By default, resources will be placed in the `app/Http/Resources` directory of your application. Resources extend the `Hypervel\Http\Resources\Json\JsonResource` class:
-
-```shell:no-line-numbers
-php artisan make:resource User
-```
-
-#### Resource Collections
-
-In addition to generating resources that transform individual models, you may generate resources that are responsible for transforming collections of models. This allows your response to include links and other meta information that is relevant to an entire collection of a given resource.
-
-To create a resource collection, you should use the `--collection` flag when creating the resource. Or, including the word `Collection` in the resource name will indicate to Hypervel that it should create a collection resource. Collection resources extend the `Hypervel\Http\Resources\Json\ResourceCollection` class:
-
-```shell:no-line-numbers
-php artisan make:resource Users --collection
-
-php artisan make:resource UserCollection
-```
-
-## Concept Overview
-
-::: tip
-This is a high-level overview of resources and resource collections. You are highly encouraged to read the other sections of this documentation to gain a deeper understanding of the customization and power offered to you by resources.
-:::
-
-Before diving into all of the options available to you when writing resources, let's first take a high-level look at how resources are used within Hypervel. A resource class represents a single model that needs to be transformed into a JSON structure. For example, here is a simple `User` resource class:
-
-```php
- $this->id,
- 'name' => $this->name,
- 'email' => $this->email,
- 'created_at' => $this->created_at,
- 'updated_at' => $this->updated_at,
- ];
- }
-}
-```
-
-Every resource class defines a `toArray` method which returns the array of attributes that should be converted to JSON when sending the response. Notice that we can access model properties directly from the `$this` variable. This is because a resource class will automatically proxy property and method access down to the underlying model for convenient access. Once the resource is defined, it may be returned from a route or controller:
-
-```php
-use App\Http\Resources\User as UserResource;
-use App\User;
-
-Route::get('/user', function () {
- return new UserResource(User::find(1));
-});
-```
-
-### Resource Collections
-
-If you are returning a collection of resources or a paginated response, you may use the `collection` method when creating the resource instance in your route or controller:
-
-```php
-use App\Http\Resources\User as UserResource;
-use App\User;
-
-Route::get('/user', function () {
- return UserResource::collection(User::all());
-});
-```
-
-Note that this does not allow any addition of meta data that may need to be returned with the collection. If you would like to customize the resource collection response, you may create a dedicated resource to represent the collection:
-
-```shell:no-line-numbers
-php artisan make:resource UserCollection
-```
-
-Once the resource collection class has been generated, you may easily define any meta data that should be included with the response:
-
-```php
- $this->collection,
- 'links' => [
- 'self' => 'link-value',
- ],
- ];
- }
-}
-```
-
-After defining your resource collection, it may be returned from a route or controller:
-
-```php
-use App\Http\Resources\UserCollection;
-use App\User;
-
-Route::get('/users', function () {
- return new UserCollection(User::all());
-});
-```
-
-#### Preserving Collection Keys
-
-When returning a resource collection from a route, Hypervel resets the collection's keys so that they are in simple numerical order. However, you may add a `preserveKeys` property to your resource class indicating if collection keys should be preserved:
-
-```php
-keyBy->id);
-});
-```
-
-#### Customizing The Underlying Resource Class
-
-Typically, the `$this->collection` property of a resource collection is automatically populated with the result of mapping each item of the collection to its singular resource class. The singular resource class is assumed to be the collection's class name without the trailing `Collection` string.
-
-For example, `UserCollection` will attempt to map the given user instances into the `User` resource. To customize this behavior, you may override the `$collects` property of your resource collection:
-
-```php
- $this->id,
- 'name' => $this->name,
- 'email' => $this->email,
- 'created_at' => $this->created_at,
- 'updated_at' => $this->updated_at,
- ];
- }
-}
-```
-
-Once a resource has been defined, it may be returned directly from a route or controller:
-
-```php
-use App\Http\Resources\User as UserResource;
-use App\User;
-
-Route::get('/user', function () {
- return new UserResource(User::find(1));
-});
-```
-
-#### Relationships
-
-If you would like to include related resources in your response, you may add them to the array returned by your `toArray` method. In this example, we will use the `Post` resource's `collection` method to add the user's blog posts to the resource response:
-
-```php
-/**
- * Transform the resource into an array.
- *
- * @return array
- */
-public function toArray()
-{
- return [
- 'id' => $this->id,
- 'name' => $this->name,
- 'email' => $this->email,
- 'posts' => PostResource::collection($this->posts),
- 'created_at' => $this->created_at,
- 'updated_at' => $this->updated_at,
- ];
-}
-```
-
-::: tip
-If you would like to include relationships only when they have already been loaded, check out the documentation on [conditional relationships](#conditional-relationships).
-:::
-
-#### Resource Collections
-
-While resources translate a single model into an array, resource collections translate a collection of models into an array. It is not absolutely necessary to define a resource collection class for each one of your model types since all resources provide a `collection` method to generate an "ad-hoc" resource collection on the fly:
-
-```php
-use App\Http\Resources\User as UserResource;
-use App\User;
-
-Route::get('/user', function () {
- return UserResource::collection(User::all());
-});
-```
-
-However, if you need to customize the meta data returned with the collection, it will be necessary to define a resource collection:
-
-```php
- $this->collection,
- 'links' => [
- 'self' => 'link-value',
- ],
- ];
- }
-}
-```
-
-Like singular resources, resource collections may be returned directly from routes or controllers:
-
-```php
-use App\Http\Resources\UserCollection;
-use App\User;
-
-Route::get('/users', function () {
- return new UserCollection(User::all());
-});
-```
-
-### Data Wrapping
-
-By default, your outermost resource is wrapped in a `data` key when the resource response is converted to JSON. So, for example, a typical resource collection response looks like the following:
-
-```json
-{
- "data": [
- {
- "id": 1,
- "name": "Eladio Schroeder Sr.",
- "email": "therese28@example.com",
- },
- {
- "id": 2,
- "name": "Liliana Mayert",
- "email": "evandervort@example.com",
- }
- ]
-}
-```
-
-If you would like to disable the wrapping of the outermost resource, you may use the `withoutWrapping` method on the base resource class:
-
-```php
-withoutWrapping()
- ->toResponse();
- }
-}
-```
-
-::: note
-The `withoutWrapping` method only affects the outermost response and will not remove `data` keys that you manually add to your own resource collections.
-:::
-
-### Wrapping Nested Resources
-
-You have total freedom to determine how your resource's relationships are wrapped. If you would like all resource collections to be wrapped in a `data` key, regardless of their nesting, you should define a resource collection class for each resource and return the collection within a `data` key.
-
-You may be wondering if this will cause your outermost resource to be wrapped in two `data` keys. Don't worry, Hypervel will never let your resources be accidentally double-wrapped, so you don't have to be concerned about the nesting level of the resource collection you are transforming:
-
-```php
- $this->collection];
- }
-}
-```
-
-### Data Wrapping And Pagination
-
-When returning paginated collections in a resource response, Hypervel will wrap your resource data in a `data` key even if the `withoutWrapping` method has been called. This is because paginated responses always contain `meta` and `links` keys with information about the paginator's state:
-
-```json
-{
- "data": [
- {
- "id": 1,
- "name": "Eladio Schroeder Sr.",
- "email": "therese28@example.com",
- },
- {
- "id": 2,
- "name": "Liliana Mayert",
- "email": "evandervort@example.com",
- }
- ],
- "links":{
- "first": "http://example.com/pagination?page=1",
- "last": "http://example.com/pagination?page=1",
- "prev": null,
- "next": null
- },
- "meta":{
- "current_page": 1,
- "from": 1,
- "last_page": 1,
- "path": "http://example.com/pagination",
- "per_page": 15,
- "to": 10,
- "total": 10
- }
-}
-```
-
-### Pagination
-
-You may always pass a paginator instance to the `collection` method of a resource or to a custom resource collection:
-
-```php
-use App\Http\Resources\UserCollection;
-use App\User;
-
-Route::get('/users', function () {
- return new UserCollection(User::paginate());
-});
-```
-
-Paginated responses always contain `meta` and `links` keys with information about the paginator's state:
-
-```json
-{
- "data": [
- {
- "id": 1,
- "name": "Eladio Schroeder Sr.",
- "email": "therese28@example.com",
- },
- {
- "id": 2,
- "name": "Liliana Mayert",
- "email": "evandervort@example.com",
- }
- ],
- "links":{
- "first": "http://example.com/pagination?page=1",
- "last": "http://example.com/pagination?page=1",
- "prev": null,
- "next": null
- },
- "meta":{
- "current_page": 1,
- "from": 1,
- "last_page": 1,
- "path": "http://example.com/pagination",
- "per_page": 15,
- "to": 10,
- "total": 10
- }
-}
-```
-
-### Conditional Attributes
-
-Sometimes you may wish to only include an attribute in a resource response if a given condition is met. For example, you may wish to only include a value if the current user is an "administrator". Hypervel provides a variety of helper methods to assist you in this situation. The `when` method may be used to conditionally add an attribute to a resource response:
-
-```php
-/**
- * Transform the resource into an array.
- *
- * @return array
- */
-public function toArray()
-{
- return [
- 'id' => $this->id,
- 'name' => $this->name,
- 'email' => $this->email,
- 'secret' => $this->when(Auth::user()->isAdmin(), 'secret-value'),
- 'created_at' => $this->created_at,
- 'updated_at' => $this->updated_at,
- ];
-}
-```
-
-In this example, the `secret` key will only be returned in the final resource response if the authenticated user's `isAdmin` method returns `true`. If the method returns `false`, the `secret` key will be removed from the resource response entirely before it is sent back to the client. The `when` method allows you to expressively define your resources without resorting to conditional statements when building the array.
-
-The `when` method also accepts a Closure as its second argument, allowing you to calculate the resulting value only if the given condition is `true`:
-
-```php
-'secret' => $this->when(Auth::user()->isAdmin(), function () {
- return 'secret-value';
-}),
-```
-
-#### Merging Conditional Attributes
-
-Sometimes you may have several attributes that should only be included in the resource response based on the same condition. In this case, you may use the `mergeWhen` method to include the attributes in the response only when the given condition is `true`:
-
-```php
-/**
- * Transform the resource into an array.
- *
- * @return array
- */
-public function toArray()
-{
- return [
- 'id' => $this->id,
- 'name' => $this->name,
- 'email' => $this->email,
- $this->mergeWhen(Auth::user()->isAdmin(), [
- 'first-secret' => 'value',
- 'second-secret' => 'value',
- ]),
- 'created_at' => $this->created_at,
- 'updated_at' => $this->updated_at,
- ];
-}
-```
-
-Again, if the given condition is `false`, these attributes will be removed from the resource response entirely before it is sent to the client.
-
-::: note
-The `mergeWhen` method should not be used within arrays that mix string and numeric keys. Furthermore, it should not be used within arrays with numeric keys that are not ordered sequentially.
-:::
-
-### Conditional Relationships
-
-In addition to conditionally loading attributes, you may conditionally include relationships on your resource responses based on if the relationship has already been loaded on the model. This allows your controller to decide which relationships should be loaded on the model and your resource can easily include them only when they have actually been loaded.
-
-Ultimately, this makes it easier to avoid "N+1" query problems within your resources. The `whenLoaded` method may be used to conditionally load a relationship. In order to avoid unnecessarily loading relationships, this method accepts the name of the relationship instead of the relationship itself:
-
-```php
-/**
- * Transform the resource into an array.
- *
- * @return array
- */
-public function toArray()
-{
- return [
- 'id' => $this->id,
- 'name' => $this->name,
- 'email' => $this->email,
- 'posts' => PostResource::collection($this->whenLoaded('posts')),
- 'created_at' => $this->created_at,
- 'updated_at' => $this->updated_at,
- ];
-}
-```
-
-In this example, if the relationship has not been loaded, the `posts` key will be removed from the resource response entirely before it is sent to the client.
-
-#### Conditional Pivot Information
-
-In addition to conditionally including relationship information in your resource responses, you may conditionally include data from the intermediate tables of many-to-many relationships using the `whenPivotLoaded` method. The `whenPivotLoaded` method accepts the name of the pivot table as its first argument. The second argument should be a Closure that defines the value to be returned if the pivot information is available on the model:
-
-```php
-/**
- * Transform the resource into an array.
- *
- * @return array
- */
-public function toArray()
-{
- return [
- 'id' => $this->id,
- 'name' => $this->name,
- 'expires_at' => $this->whenPivotLoaded('role_user', function () {
- return $this->pivot->expires_at;
- }),
- ];
-}
-```
-
-If your intermediate table is using an accessor other than `pivot`, you may use the `whenPivotLoadedAs` method:
-
-```php
- /**
- * Transform the resource into an array.
- *
- * @return array
- */
- public function toArray()
- {
- return [
- 'id' => $this->id,
- 'name' => $this->name,
- 'expires_at' => $this->whenPivotLoadedAs('subscription', 'role_user', function () {
- return $this->subscription->expires_at;
- }),
- ];
- }
-```
-
-### Adding Meta Data
-
-Some JSON API standards require the addition of meta data to your resource and resource collections responses. This often includes things like `links` to the resource or related resources, or meta data about the resource itself. If you need to return additional meta data about a resource, include it in your `toArray` method. For example, you might include `link` information when transforming a resource collection:
-
-```php
-/**
- * Transform the resource into an array.
- *
- * @return array
- */
-public function toArray()
-{
- return [
- 'data' => $this->collection,
- 'links' => [
- 'self' => 'link-value',
- ],
- ];
-}
-```
-
-When returning additional meta data from your resources, you never have to worry about accidentally overriding the `links` or `meta` keys that are automatically added by Hypervel when returning paginated responses. Any additional `links` you define will be merged with the links provided by the paginator.
-
-#### Top Level Meta Data
-
-Sometimes you may wish to only include certain meta data with a resource response if the resource is the outermost resource being returned. Typically, this includes meta information about the response as a whole. To define this meta data, add a `with` method to your resource class. This method should return an array of meta data to be included with the resource response only when the resource is the outermost resource being rendered:
-
-```php
- [
- 'key' => 'value',
- ],
- ];
- }
-}
-```
-
-#### Adding Meta Data When Constructing Resources
-
-You may also add top-level data when constructing resource instances in your route or controller. The `additional` method, which is available on all resources, accepts an array of data that should be added to the resource response:
-
-```php
-return (new UserCollection(User::all()->load('roles')))
- ->additional(['meta' => [
- 'key' => 'value',
- ]]);
-```
-## Resource Responses
-
-As you have already read, resources may be returned directly from routes and controllers:
-
-```php
-use App\Http\Resources\User as UserResource;
-use App\User;
-
-Route::get('/user', function () {
- return new UserResource(User::find(1));
-});
-```
-
-However, sometimes you may need to customize the outgoing HTTP response before it is sent to the client. There are two ways to accomplish this. First, you may chain the `response` method onto the resource. This method will return an `Hyperf\HttpMessage\Base\Response` instance, allowing you full control of the response's headers:
-
-```php
-use App\Http\Resources\User as UserResource;
-use App\User;
-
-Route::get('/user', function () {
- return (new UserResource(User::find(1)))
- ->toResponse()
- ->withHeader('X-Value', 'True');
-});
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/eloquent-serialization.md b/_archive/docs/0.3/docs/eloquent-serialization.md
deleted file mode 100644
index cf1f6e8a81..0000000000
--- a/_archive/docs/0.3/docs/eloquent-serialization.md
+++ /dev/null
@@ -1,188 +0,0 @@
-# Eloquent: Serialization
-[[toc]]
-
-## Introduction
-
-When building JSON APIs, you will often need to convert your models and relationships to arrays or JSON. Eloquent includes convenient methods for making these conversions, as well as controlling which attributes are included in your serializations.
-
-## Serializing Models & Collections
-
-### Serializing To Arrays
-
-To convert a model and its loaded [relationships](/docs/eloquent-relationships) to an array, you should use the `toArray` method. This method is recursive, so all attributes and all relations (including the relations of relations) will be converted to arrays:
-
-```php
-$user = App\User::with('roles')->first();
-
-return $user->toArray();
-```
-
-To convert only a model's attributes to an array, use the `attributesToArray` method:
-
-```php
-$user = App\User::first();
-
-return $user->attributesToArray();
-```
-
-You may also convert entire [collections](/docs/eloquent-collections) of models to arrays:
-
-```php
-$users = App\User::all();
-
-return $users->toArray();
-```
-
-### Serializing To JSON
-
-To convert a model to JSON, you should use the `toJson` method. Like `toArray`, the `toJson` method is recursive, so all attributes and relations will be converted to JSON. You may also specify JSON encoding options [supported by PHP](https://secure.php.net/manual/en/function.json-encode.php):
-
-```php
-$user = App\User::find(1);
-
-return $user->toJson();
-
-return $user->toJson(JSON_PRETTY_PRINT);
-```
-
-Alternatively, you may cast a model or collection to a string, which will automatically call the `toJson` method on the model or collection:
-
-```php
-$user = App\User::find(1);
-
-return (string) $user;
-```
-
-Since models and collections are converted to JSON when cast to a string, you can return Eloquent objects directly from your application's routes or controllers:
-
-```php
-Route::get('users', function () {
- return App\User::all();
-});
-```
-
-#### Relationships
-
-When an Eloquent model is converted to JSON, its loaded relationships will automatically be included as attributes on the JSON object. Also, though Eloquent relationship methods are defined using "camel case", a relationship's JSON attribute will be "snake case".
-
-## Hiding Attributes From JSON
-
-Sometimes you may wish to limit the attributes, such as passwords, that are included in your model's array or JSON representation. To do so, add a `$hidden` property to your model:
-
-```php
-makeVisible('attribute')->toArray();
-```
-
-Likewise, if you would like to make some typically visible attributes hidden on a given model instance, you may use the `makeHidden` method.
-
-```php
-return $user->makeHidden('attribute')->toArray();
-```
-
-## Appending Values To JSON
-
-Occasionally, when casting models to an array or JSON, you may wish to add attributes that do not have a corresponding column in your database. To do so, first define an [accessor](/docs/eloquent-mutators) for the value:
-
-```php
-attributes['admin'] === 'yes';
- }
-}
-```
-
-After creating the accessor, add the attribute name to the `appends` property on the model. Note that attribute names are typically referenced in "snake case", even though the accessor is defined using "camel case":
-
-```php
-append('is_admin')->toArray();
-
-return $user->setAppends(['is_admin'])->toArray();
-```
-
-## Date Serialization
-
-#### Customizing The Date Format Per Attribute
-
-You may customize the serialization format of individual Eloquent date attributes by specifying the date format in the [cast declaration](/docs/eloquent-mutators#attribute-casting):
-
-```php
-protected array $casts = [
- 'birthday' => 'date:Y-m-d',
- 'joined_at' => 'datetime:Y-m-d H:00',
-];
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/eloquent.md b/_archive/docs/0.3/docs/eloquent.md
deleted file mode 100644
index 4fabdca6ae..0000000000
--- a/_archive/docs/0.3/docs/eloquent.md
+++ /dev/null
@@ -1,1536 +0,0 @@
-# Eloquent: Getting Started
-[[toc]]
-
-## Introduction
-
-Hypervel includes Eloquent, an object-relational mapper (ORM) that makes it enjoyable to interact with your database. When using Eloquent, each database table has a corresponding "Model" that is used to interact with that table. In addition to retrieving records from the database table, Eloquent models allow you to insert, update, and delete records from the table as well.
-
-::: note
-Before getting started, be sure to configure a database connection in your application's `config/database.php` configuration file. For more information on configuring your database, check out [the database configuration documentation](/docs/database#configuration).
-:::
-
-::: note
-Hypervel's Eloquent is a forked version in the Hyperf framework, which was derived from an early version of Laravel. Some newer Eloquent features from recent Laravel versions may not be supported in this component.
-:::
-
-## Generating Model Classes
-
-To get started, let's create an Eloquent model. Models typically live in the `app\Models` directory and extend the `Hypervel\Database\Eloquent\Model` class. You may use the `make:model` [Artisan command](/docs/artisan) to generate a new model:
-
-```shell:no-line-numbers
-php artisan make:model Flight
-```
-
-If you would like to generate a [database migration](/docs/migrations) when you generate the model, you may use the `--migration` or `-m` option:
-
-```shell:no-line-numbers
-php artisan make:model Flight --migration
-```
-
-You may generate various other types of classes when generating a model, such as factories, seeders, policies, controllers, and form requests. In addition, these options may be combined to create multiple classes at once:
-
-```shell:no-line-numbers
-# Generate a model and a FlightFactory class...
-php artisan make:model Flight --factory
-php artisan make:model Flight -f
-
-# Generate a model and a FlightSeeder class...
-php artisan make:model Flight --seed
-php artisan make:model Flight -s
-
-# Shortcut to generate a model, migration, factory, seeder, policy, controller, and form requests...
-php artisan make:model Flight --all
-php artisan make:model Flight -a
-```
-
-## Eloquent Model Conventions
-
-Models generated by the `make:model` command will be placed in the `app/Models` directory. Let's examine a basic model class and discuss some of Eloquent's key conventions:
-
-```php
- 'Traveling to Europe']);
-
-$article->id; // "8f8e8478-9035-4d23-b9a7-62f4d2612ce5"
-```
-
-By default, The `HasUuids` trait will generate ["ordered" UUIDs](/docs/strings#method-str-ordered-uuid) for your models. These UUIDs are more efficient for indexed database storage because they can be sorted lexicographically.
-
-You can override the UUID generation process for a given model by defining a `newUniqueId` method on the model. In addition, you may specify which columns should receive UUIDs by defining a `uniqueIds` method on the model:
-
-```php
-use Ramsey\Uuid\Uuid;
-
-/**
- * Generate a new UUID for the model.
- */
-public function newUniqueId(): string
-{
- return (string) Uuid::uuid4();
-}
-
-/**
- * Get the columns that should receive a unique identifier.
- *
- * @return array
-
-[Arr::accessible](#method-array-accessible)
-[Arr::add](#method-array-add)
-[Arr::collapse](#method-array-collapse)
-[Arr::crossJoin](#method-array-crossjoin)
-[Arr::divide](#method-array-divide)
-[Arr::dot](#method-array-dot)
-[Arr::except](#method-array-except)
-[Arr::exists](#method-array-exists)
-[Arr::first](#method-array-first)
-[Arr::flatten](#method-array-flatten)
-[Arr::forget](#method-array-forget)
-[Arr::get](#method-array-get)
-[Arr::has](#method-array-has)
-[Arr::hasAny](#method-array-hasany)
-[Arr::isAssoc](#method-array-isassoc)
-[Arr::isList](#method-array-islist)
-[Arr::join](#method-array-join)
-[Arr::keyBy](#method-array-keyby)
-[Arr::last](#method-array-last)
-[Arr::map](#method-array-map)
-[Arr::mapWithKeys](#method-array-map-with-keys)
-[Arr::only](#method-array-only)
-[Arr::pluck](#method-array-pluck)
-[Arr::prepend](#method-array-prepend)
-[Arr::prependKeysWith](#method-array-prependkeyswith)
-[Arr::pull](#method-array-pull)
-[Arr::query](#method-array-query)
-[Arr::random](#method-array-random)
-[Arr::set](#method-array-set)
-[Arr::shuffle](#method-array-shuffle)
-[Arr::sort](#method-array-sort)
-[Arr::sortDesc](#method-array-sort-desc)
-[Arr::sortRecursive](#method-array-sort-recursive)
-[Arr::sortRecursiveDesc](#method-array-sort-recursive-desc)
-[Arr::toCssClasses](#method-array-to-css-classes)
-[Arr::toCssStyles](#method-array-to-css-styles)
-[Arr::undot](#method-array-undot)
-[Arr::where](#method-array-where)
-[Arr::whereNotNull](#method-array-where-not-null)
-[Arr::wrap](#method-array-wrap)
-[data_fill](#method-data-fill)
-[data_get](#method-data-get)
-[data_set](#method-data-set)
-[data_forget](#method-data-forget)
-[head](#method-head)
-[last](#method-last)
-
-
-
-### Numbers
-
-
-
-[Number::abbreviate](#method-number-abbreviate)
-[Number::clamp](#method-number-clamp)
-[Number::currency](#method-number-currency)
-[Number::fileSize](#method-number-file-size)
-[Number::forHumans](#method-number-for-humans)
-[Number::format](#method-number-format)
-[Number::ordinal](#method-number-ordinal)
-[Number::percentage](#method-number-percentage)
-[Number::spell](#method-number-spell)
-[Number::useLocale](#method-number-use-locale)
-[Number::withLocale](#method-number-with-locale)
-
-
-
-
-
-### Paths
-
-
-
-[app_path](#method-app-path)
-[base_path](#method-base-path)
-[config_path](#method-config-path)
-[database_path](#method-database-path)
-[lang_path](#method-lang-path)
-[public_path](#method-public-path)
-[resource_path](#method-resource-path)
-[storage_path](#method-storage-path)
-
-
-
-
-### URLs
-
-
-
-[asset](#method-asset)
-[route](#method-route)
-[secure_asset](#method-secure-asset)
-[secure_url](#method-secure-url)
-[to_route](#method-to-route)
-[url](#method-url)
-
-
-
-
-### Miscellaneous
-
-
-
-[abort](#method-abort)
-[abort_if](#method-abort-if)
-[abort_unless](#method-abort-unless)
-[app](#method-app)
-[auth](#method-auth)
-[bcrypt](#method-bcrypt)
-[blank](#method-blank)
-[cache](#method-cache)
-[class_uses_recursive](#method-class-uses-recursive)
-[collect](#method-collect)
-[config](#method-config)
-[cookie](#method-cookie)
-[decrypt](#method-decrypt)
-[dd](#method-dd)
-[dispatch](#method-dispatch)
-[dump](#method-dump)
-[encrypt](#method-encrypt)
-[env](#method-env)
-[event](#method-event)
-[filled](#method-filled)
-[info](#method-info)
-[logger](#method-logger)
-[method_field](#method-method-field)
-[now](#method-now)
-[optional](#method-optional)
-[policy](#method-policy)
-[redirect](#method-redirect)
-[report](#method-report)
-[report_if](#method-report-if)
-[report_unless](#method-report-unless)
-[request](#method-request)
-[rescue](#method-rescue)
-[resolve](#method-resolve)
-[response](#method-response)
-[retry](#method-retry)
-[session](#method-session)
-[tap](#method-tap)
-[throw_if](#method-throw-if)
-[throw_unless](#method-throw-unless)
-[today](#method-today)
-[trait_uses_recursive](#method-trait-uses-recursive)
-[transform](#method-transform)
-[validator](#method-validator)
-[value](#method-value)
-[view](#method-view)
-[with](#method-with)
-
-
-
-
-## Arrays & Objects
-
-
-#### `Arr::accessible()` {.collection-method .first-collection-method}
-
-The `Arr::accessible` method determines if the given value is array accessible:
-
-```php
-use Hypervel\Support\Arr;
-use Hyperf\Collection\Collection;
-
-$isAccessible = Arr::accessible(['a' => 1, 'b' => 2]);
-
-// true
-
-$isAccessible = Arr::accessible(new Collection);
-
-// true
-
-$isAccessible = Arr::accessible('abc');
-
-// false
-
-$isAccessible = Arr::accessible(new stdClass);
-
-// false
-```
-
-
-#### `Arr::add()`
-
-The `Arr::add` method adds a given key / value pair to an array if the given key doesn't already exist in the array or is set to `null`:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = Arr::add(['name' => 'Desk'], 'price', 100);
-
-// ['name' => 'Desk', 'price' => 100]
-
-$array = Arr::add(['name' => 'Desk', 'price' => null], 'price', 100);
-
-// ['name' => 'Desk', 'price' => 100]
-```
-
-
-#### `Arr::collapse()`
-
-The `Arr::collapse` method collapses an array of arrays into a single array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = Arr::collapse([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
-
-// [1, 2, 3, 4, 5, 6, 7, 8, 9]
-```
-
-
-#### `Arr::crossJoin()`
-
-The `Arr::crossJoin` method cross joins the given arrays, returning a Cartesian product with all possible permutations:
-
-```php
-use Hypervel\Support\Arr;
-
-$matrix = Arr::crossJoin([1, 2], ['a', 'b']);
-
-/*
- [
- [1, 'a'],
- [1, 'b'],
- [2, 'a'],
- [2, 'b'],
- ]
-*/
-
-$matrix = Arr::crossJoin([1, 2], ['a', 'b'], ['I', 'II']);
-
-/*
- [
- [1, 'a', 'I'],
- [1, 'a', 'II'],
- [1, 'b', 'I'],
- [1, 'b', 'II'],
- [2, 'a', 'I'],
- [2, 'a', 'II'],
- [2, 'b', 'I'],
- [2, 'b', 'II'],
- ]
-*/
-```
-
-
-#### `Arr::divide()`
-
-The `Arr::divide` method returns two arrays: one containing the keys and the other containing the values of the given array:
-
-```php
-use Hypervel\Support\Arr;
-
-[$keys, $values] = Arr::divide(['name' => 'Desk']);
-
-// $keys: ['name']
-
-// $values: ['Desk']
-```
-
-
-#### `Arr::dot()`
-
-The `Arr::dot` method flattens a multi-dimensional array into a single level array that uses "dot" notation to indicate depth:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['products' => ['desk' => ['price' => 100]]];
-
-$flattened = Arr::dot($array);
-
-// ['products.desk.price' => 100]
-```
-
-
-#### `Arr::except()`
-
-The `Arr::except` method removes the given key / value pairs from an array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['name' => 'Desk', 'price' => 100];
-
-$filtered = Arr::except($array, ['price']);
-
-// ['name' => 'Desk']
-```
-
-
-#### `Arr::exists()`
-
-The `Arr::exists` method checks that the given key exists in the provided array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['name' => 'John Doe', 'age' => 17];
-
-$exists = Arr::exists($array, 'name');
-
-// true
-
-$exists = Arr::exists($array, 'salary');
-
-// false
-```
-
-
-#### `Arr::first()`
-
-The `Arr::first` method returns the first element of an array passing a given truth test:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [100, 200, 300];
-
-$first = Arr::first($array, function (int $value, int $key) {
- return $value >= 150;
-});
-
-// 200
-```
-
-A default value may also be passed as the third parameter to the method. This value will be returned if no value passes the truth test:
-
-```php
-use Hypervel\Support\Arr;
-
-$first = Arr::first($array, $callback, $default);
-```
-
-
-#### `Arr::flatten()`
-
-The `Arr::flatten` method flattens a multi-dimensional array into a single level array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['name' => 'Joe', 'languages' => ['PHP', 'Ruby']];
-
-$flattened = Arr::flatten($array);
-
-// ['Joe', 'PHP', 'Ruby']
-```
-
-
-#### `Arr::forget()`
-
-The `Arr::forget` method removes a given key / value pair from a deeply nested array using "dot" notation:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['products' => ['desk' => ['price' => 100]]];
-
-Arr::forget($array, 'products.desk');
-
-// ['products' => []]
-```
-
-
-#### `Arr::get()`
-
-The `Arr::get` method retrieves a value from a deeply nested array using "dot" notation:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['products' => ['desk' => ['price' => 100]]];
-
-$price = Arr::get($array, 'products.desk.price');
-
-// 100
-```
-
-The `Arr::get` method also accepts a default value, which will be returned if the specified key is not present in the array:
-
-```php
-use Hypervel\Support\Arr;
-
-$discount = Arr::get($array, 'products.desk.discount', 0);
-
-// 0
-```
-
-
-#### `Arr::has()`
-
-The `Arr::has` method checks whether a given item or items exists in an array using "dot" notation:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['product' => ['name' => 'Desk', 'price' => 100]];
-
-$contains = Arr::has($array, 'product.name');
-
-// true
-
-$contains = Arr::has($array, ['product.price', 'product.discount']);
-
-// false
-```
-
-
-#### `Arr::hasAny()`
-
-The `Arr::hasAny` method checks whether any item in a given set exists in an array using "dot" notation:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['product' => ['name' => 'Desk', 'price' => 100]];
-
-$contains = Arr::hasAny($array, 'product.name');
-
-// true
-
-$contains = Arr::hasAny($array, ['product.name', 'product.discount']);
-
-// true
-
-$contains = Arr::hasAny($array, ['category', 'product.discount']);
-
-// false
-```
-
-
-#### `Arr::isAssoc()`
-
-The `Arr::isAssoc` method returns `true` if the given array is an associative array. An array is considered "associative" if it doesn't have sequential numerical keys beginning with zero:
-
-```php
-use Hypervel\Support\Arr;
-
-$isAssoc = Arr::isAssoc(['product' => ['name' => 'Desk', 'price' => 100]]);
-
-// true
-
-$isAssoc = Arr::isAssoc([1, 2, 3]);
-
-// false
-```
-
-
-#### `Arr::isList()`
-
-The `Arr::isList` method returns `true` if the given array's keys are sequential integers beginning from zero:
-
-```php
-use Hypervel\Support\Arr;
-
-$isList = Arr::isList(['foo', 'bar', 'baz']);
-
-// true
-
-$isList = Arr::isList(['product' => ['name' => 'Desk', 'price' => 100]]);
-
-// false
-```
-
-
-#### `Arr::join()`
-
-The `Arr::join` method joins array elements with a string. Using this method's second argument, you may also specify the joining string for the final element of the array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['Tailwind', 'Alpine', 'Laravel', 'Hyperf'];
-
-$joined = Arr::join($array, ', ');
-
-// Tailwind, Alpine, Laravel, Hyperf
-
-$joined = Arr::join($array, ', ', ' and ');
-
-// Tailwind, Alpine, Laravel and Hyperf
-```
-
-
-#### `Arr::keyBy()`
-
-The `Arr::keyBy` method keys the array by the given key. If multiple items have the same key, only the last one will appear in the new array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [
- ['product_id' => 'prod-100', 'name' => 'Desk'],
- ['product_id' => 'prod-200', 'name' => 'Chair'],
-];
-
-$keyed = Arr::keyBy($array, 'product_id');
-
-/*
- [
- 'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
- 'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
- ]
-*/
-```
-
-
-#### `Arr::last()`
-
-The `Arr::last` method returns the last element of an array passing a given truth test:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [100, 200, 300, 110];
-
-$last = Arr::last($array, function (int $value, int $key) {
- return $value >= 150;
-});
-
-// 300
-```
-
-A default value may be passed as the third argument to the method. This value will be returned if no value passes the truth test:
-
-```php
-use Hypervel\Support\Arr;
-
-$last = Arr::last($array, $callback, $default);
-```
-
-
-#### `Arr::map()`
-
-The `Arr::map` method iterates through the array and passes each value and key to the given callback. The array value is replaced by the value returned by the callback:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['first' => 'james', 'last' => 'kirk'];
-
-$mapped = Arr::map($array, function (string $value, string $key) {
- return ucfirst($value);
-});
-
-// ['first' => 'James', 'last' => 'Kirk']
-```
-
-
-#### `Arr::mapWithKeys()`
-
-The `Arr::mapWithKeys` method iterates through the array and passes each value to the given callback. The callback should return an associative array containing a single key / value pair:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [
- [
- 'name' => 'John',
- 'department' => 'Sales',
- 'email' => 'john@example.com',
- ],
- [
- 'name' => 'Jane',
- 'department' => 'Marketing',
- 'email' => 'jane@example.com',
- ]
-];
-
-$mapped = Arr::mapWithKeys($array, function (array $item, int $key) {
- return [$item['email'] => $item['name']];
-});
-
-/*
- [
- 'john@example.com' => 'John',
- 'jane@example.com' => 'Jane',
- ]
-*/
-```
-
-
-#### `Arr::only()`
-
-The `Arr::only` method returns only the specified key / value pairs from the given array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['name' => 'Desk', 'price' => 100, 'orders' => 10];
-
-$slice = Arr::only($array, ['name', 'price']);
-
-// ['name' => 'Desk', 'price' => 100]
-```
-
-
-#### `Arr::pluck()`
-
-The `Arr::pluck` method retrieves all of the values for a given key from an array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [
- ['developer' => ['id' => 1, 'name' => 'Taylor']],
- ['developer' => ['id' => 2, 'name' => 'Abigail']],
-];
-
-$names = Arr::pluck($array, 'developer.name');
-
-// ['Taylor', 'Abigail']
-
-You may also specify how you wish the resulting list to be keyed:
-
-use Hypervel\Support\Arr;
-
-$names = Arr::pluck($array, 'developer.name', 'developer.id');
-
-// [1 => 'Taylor', 2 => 'Abigail']
-```
-
-
-#### `Arr::prepend()`
-
-The `Arr::prepend` method will push an item onto the beginning of an array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['one', 'two', 'three', 'four'];
-
-$array = Arr::prepend($array, 'zero');
-
-// ['zero', 'one', 'two', 'three', 'four']
-```
-
-If needed, you may specify the key that should be used for the value:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['price' => 100];
-
-$array = Arr::prepend($array, 'Desk', 'name');
-
-// ['name' => 'Desk', 'price' => 100]
-```
-
-
-#### `Arr::prependKeysWith()`
-
-The `Arr::prependKeysWith` prepends all key names of an associative array with the given prefix:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [
- 'name' => 'Desk',
- 'price' => 100,
-];
-
-$keyed = Arr::prependKeysWith($array, 'product.');
-
-/*
- [
- 'product.name' => 'Desk',
- 'product.price' => 100,
- ]
-*/
-```
-
-
-#### `Arr::pull()`
-
-The `Arr::pull` method returns and removes a key / value pair from an array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['name' => 'Desk', 'price' => 100];
-
-$name = Arr::pull($array, 'name');
-
-// $name: Desk
-
-// $array: ['price' => 100]
-```
-
-A default value may be passed as the third argument to the method. This value will be returned if the key doesn't exist:
-
-```php
-use Hypervel\Support\Arr;
-
-$value = Arr::pull($array, $key, $default);
-```
-
-
-#### `Arr::query()`
-
-The `Arr::query` method converts the array into a query string:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [
- 'name' => 'Taylor',
- 'order' => [
- 'column' => 'created_at',
- 'direction' => 'desc'
- ]
-];
-
-Arr::query($array);
-
-// name=Taylor&order[column]=created_at&order[direction]=desc
-```
-
-
-#### `Arr::random()`
-
-The `Arr::random` method returns a random value from an array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [1, 2, 3, 4, 5];
-
-$random = Arr::random($array);
-
-// 4 - (retrieved randomly)
-```
-
-You may also specify the number of items to return as an optional second argument. Note that providing this argument will return an array even if only one item is desired:
-
-```php
-use Hypervel\Support\Arr;
-
-$items = Arr::random($array, 2);
-
-// [2, 5] - (retrieved randomly)
-```
-
-
-#### `Arr::set()`
-
-The `Arr::set` method sets a value within a deeply nested array using "dot" notation:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['products' => ['desk' => ['price' => 100]]];
-
-Arr::set($array, 'products.desk.price', 200);
-
-// ['products' => ['desk' => ['price' => 200]]]
-```
-
-
-#### `Arr::shuffle()`
-
-The `Arr::shuffle` method randomly shuffles the items in the array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = Arr::shuffle([1, 2, 3, 4, 5]);
-
-// [3, 2, 5, 1, 4] - (generated randomly)
-```
-
-
-#### `Arr::sort()`
-
-The `Arr::sort` method sorts an array by its values:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['Desk', 'Table', 'Chair'];
-
-$sorted = Arr::sort($array);
-
-// ['Chair', 'Desk', 'Table']
-```
-
-You may also sort the array by the results of a given closure:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [
- ['name' => 'Desk'],
- ['name' => 'Table'],
- ['name' => 'Chair'],
-];
-
-$sorted = array_values(Arr::sort($array, function (array $value) {
- return $value['name'];
-}));
-
-/*
- [
- ['name' => 'Chair'],
- ['name' => 'Desk'],
- ['name' => 'Table'],
- ]
-*/
-```
-
-
-#### `Arr::sortDesc()`
-
-The `Arr::sortDesc` method sorts an array in descending order by its values:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = ['Desk', 'Table', 'Chair'];
-
-$sorted = Arr::sortDesc($array);
-
-// ['Table', 'Desk', 'Chair']
-```
-
-You may also sort the array by the results of a given closure:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [
- ['name' => 'Desk'],
- ['name' => 'Table'],
- ['name' => 'Chair'],
-];
-
-$sorted = array_values(Arr::sortDesc($array, function (array $value) {
- return $value['name'];
-}));
-
-/*
- [
- ['name' => 'Table'],
- ['name' => 'Desk'],
- ['name' => 'Chair'],
- ]
-*/
-```
-
-
-#### `Arr::sortRecursive()`
-
-The `Arr::sortRecursive` method recursively sorts an array using the `sort` function for numerically indexed sub-arrays and the `ksort` function for associative sub-arrays:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [
- ['Roman', 'Taylor', 'Li'],
- ['PHP', 'Ruby', 'JavaScript'],
- ['one' => 1, 'two' => 2, 'three' => 3],
-];
-
-$sorted = Arr::sortRecursive($array);
-
-/*
- [
- ['JavaScript', 'PHP', 'Ruby'],
- ['one' => 1, 'three' => 3, 'two' => 2],
- ['Li', 'Roman', 'Taylor'],
- ]
-*/
-```
-
-If you would like the results sorted in descending order, you may use the `Arr::sortRecursiveDesc` method.
-
-```php
-$sorted = Arr::sortRecursiveDesc($array);
-```
-
-
-#### `Arr::toCssClasses()`
-
-The `Arr::toCssClasses` method conditionally compiles a CSS class string. The method accepts an array of classes where the array key contains the class or classes you wish to add, while the value is a boolean expression. If the array element has a numeric key, it will always be included in the rendered class list:
-
-```php
-use Hypervel\Support\Arr;
-
-$isActive = false;
-$hasError = true;
-
-$array = ['p-4', 'font-bold' => $isActive, 'bg-red' => $hasError];
-
-$classes = Arr::toCssClasses($array);
-
-/*
- 'p-4 bg-red'
-*/
-```
-
-
-#### `Arr::toCssStyles()`
-
-The `Arr::toCssStyles` conditionally compiles a CSS style string. The method accepts an array of classes where the array key contains the class or classes you wish to add, while the value is a boolean expression. If the array element has a numeric key, it will always be included in the rendered class list:
-
-```php
-use Hypervel\Support\Arr;
-
-$hasColor = true;
-
-$array = ['background-color: blue', 'color: blue' => $hasColor];
-
-$classes = Arr::toCssStyles($array);
-
-/*
- 'background-color: blue; color: blue;'
-*/
-```
-
-This method powers Laravel's functionality allowing [merging classes with a Blade component's attribute bag](/docs/blade#conditionally-merge-classes) as well as the `@class` [Blade directive](/docs/blade#conditional-classes).
-
-
-#### `Arr::undot()`
-
-The `Arr::undot` method expands a single-dimensional array that uses "dot" notation into a multi-dimensional array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [
- 'user.name' => 'Kevin Malone',
- 'user.occupation' => 'Accountant',
-];
-
-$array = Arr::undot($array);
-
-// ['user' => ['name' => 'Kevin Malone', 'occupation' => 'Accountant']]
-```
-
-
-#### `Arr::where()`
-
-The `Arr::where` method filters an array using the given closure:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [100, '200', 300, '400', 500];
-
-$filtered = Arr::where($array, function (string|int $value, int $key) {
- return is_string($value);
-});
-
-// [1 => '200', 3 => '400']
-```
-
-
-#### `Arr::whereNotNull()`
-
-The `Arr::whereNotNull` method removes all `null` values from the given array:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = [0, null];
-
-$filtered = Arr::whereNotNull($array);
-
-// [0 => 0]
-```
-
-
-#### `Arr::wrap()`
-
-The `Arr::wrap` method wraps the given value in an array. If the given value is already an array it will be returned without modification:
-
-```php
-use Hypervel\Support\Arr;
-
-$string = 'Laravel';
-
-$array = Arr::wrap($string);
-
-// ['Laravel']
-```
-
-If the given value is `null`, an empty array will be returned:
-
-```php
-use Hypervel\Support\Arr;
-
-$array = Arr::wrap(null);
-
-// []
-```
-
-
-#### `data_fill()`
-
-The `data_fill` function sets a missing value within a nested array or object using "dot" notation:
-
-```php
-$data = ['products' => ['desk' => ['price' => 100]]];
-
-data_fill($data, 'products.desk.price', 200);
-
-// ['products' => ['desk' => ['price' => 100]]]
-
-data_fill($data, 'products.desk.discount', 10);
-
-// ['products' => ['desk' => ['price' => 100, 'discount' => 10]]]
-```
-
-This function also accepts asterisks as wildcards and will fill the target accordingly:
-
-```php
-$data = [
- 'products' => [
- ['name' => 'Desk 1', 'price' => 100],
- ['name' => 'Desk 2'],
- ],
-];
-
-data_fill($data, 'products.*.price', 200);
-
-/*
- [
- 'products' => [
- ['name' => 'Desk 1', 'price' => 100],
- ['name' => 'Desk 2', 'price' => 200],
- ],
- ]
-*/
-```
-
-
-#### `data_get()`
-
-The `data_get` function retrieves a value from a nested array or object using "dot" notation:
-
-```php
-$data = ['products' => ['desk' => ['price' => 100]]];
-
-$price = data_get($data, 'products.desk.price');
-
-// 100
-```
-
-The `data_get` function also accepts a default value, which will be returned if the specified key is not found:
-
-```php
-$discount = data_get($data, 'products.desk.discount', 0);
-
-// 0
-```
-
-The function also accepts wildcards using asterisks, which may target any key of the array or object:
-
-```php
-$data = [
- 'product-one' => ['name' => 'Desk 1', 'price' => 100],
- 'product-two' => ['name' => 'Desk 2', 'price' => 150],
-];
-
-data_get($data, '*.name');
-
-// ['Desk 1', 'Desk 2'];
-```
-
-
-#### `data_set()`
-
-The `data_set` function sets a value within a nested array or object using "dot" notation:
-
-```php
-$data = ['products' => ['desk' => ['price' => 100]]];
-
-data_set($data, 'products.desk.price', 200);
-
-// ['products' => ['desk' => ['price' => 200]]]
-```
-
-This function also accepts wildcards using asterisks and will set values on the target accordingly:
-
-```php
-$data = [
- 'products' => [
- ['name' => 'Desk 1', 'price' => 100],
- ['name' => 'Desk 2', 'price' => 150],
- ],
-];
-
-data_set($data, 'products.*.price', 200);
-
-/*
- [
- 'products' => [
- ['name' => 'Desk 1', 'price' => 200],
- ['name' => 'Desk 2', 'price' => 200],
- ],
- ]
-*/
-```
-
-By default, any existing values are overwritten. If you wish to only set a value if it doesn't exist, you may pass `false` as the fourth argument to the function:
-
-```php
-$data = ['products' => ['desk' => ['price' => 100]]];
-
-data_set($data, 'products.desk.price', 200, overwrite: false);
-
-// ['products' => ['desk' => ['price' => 100]]]
-```
-
-
-#### `data_forget()`
-
-The `data_forget` function removes a value within a nested array or object using "dot" notation:
-
-```php
-$data = ['products' => ['desk' => ['price' => 100]]];
-
-data_forget($data, 'products.desk.price');
-
-// ['products' => ['desk' => []]]
-```
-
-This function also accepts wildcards using asterisks and will remove values on the target accordingly:
-
-```php
-$data = [
- 'products' => [
- ['name' => 'Desk 1', 'price' => 100],
- ['name' => 'Desk 2', 'price' => 150],
- ],
-];
-
-data_forget($data, 'products.*.price');
-
-/*
- [
- 'products' => [
- ['name' => 'Desk 1'],
- ['name' => 'Desk 2'],
- ],
- ]
-*/
-```
-
-
-#### `head()`
-
-The `head` function returns the first element in the given array:
-
-```php
-$array = [100, 200, 300];
-
-$first = head($array);
-
-// 100
-```
-
-
-#### `last()`
-
-The `last` function returns the last element in the given array:
-
-```php
-$array = [100, 200, 300];
-
-$last = last($array);
-
-// 300
-```
-
-
-## Numbers
-
-
-#### `Number::abbreviate()`
-
-The `Number::abbreviate` method returns the human-readable format of the provided numerical value, with an abbreviation for the units:
-
-```php
-use Hypervel\Support\Number;
-
-$number = Number::abbreviate(1000);
-
-// 1K
-
-$number = Number::abbreviate(489939);
-
-// 490K
-
-$number = Number::abbreviate(1230000, precision: 2);
-
-// 1.23M
-```
-
-
-#### `Number::clamp()`
-
-The `Number::clamp` method ensures a given number stays within a specified range. If the number is lower than the minimum, the minimum value is returned. If the number is higher than the maximum, the maximum value is returned:
-
-```php
-use Hypervel\Support\Number;
-
-$number = Number::clamp(105, min: 10, max: 100);
-
-// 100
-
-$number = Number::clamp(5, min: 10, max: 100);
-
-// 10
-
-$number = Number::clamp(10, min: 10, max: 100);
-
-// 10
-
-$number = Number::clamp(20, min: 10, max: 100);
-
-// 20
-```
-
-
-#### `Number::currency()`
-
-The `Number::currency` method returns the currency representation of the given value as a string:
-
-```php
-use Hypervel\Support\Number;
-
-$currency = Number::currency(1000);
-
-// $1,000
-
-$currency = Number::currency(1000, in: 'EUR');
-
-// €1,000
-
-$currency = Number::currency(1000, in: 'EUR', locale: 'de');
-
-// 1.000 €
-```
-
-
-#### `Number::fileSize()`
-
-The `Number::fileSize` method returns the file size representation of the given byte value as a string:
-
-```php
-use Hypervel\Support\Number;
-
-$size = Number::fileSize(1024);
-
-// 1 KB
-
-$size = Number::fileSize(1024 * 1024);
-
-// 1 MB
-
-$size = Number::fileSize(1024, precision: 2);
-
-// 1.00 KB
-```
-
-
-#### `Number::forHumans()`
-
-The `Number::forHumans` method returns the human-readable format of the provided numerical value:
-
-```php
-use Hypervel\Support\Number;
-
-$number = Number::forHumans(1000);
-
-// 1 thousand
-
-$number = Number::forHumans(489939);
-
-// 490 thousand
-
-$number = Number::forHumans(1230000, precision: 2);
-
-// 1.23 million
-```
-
-
-#### `Number::format()`
-
-The `Number::format` method formats the given number into a locale specific string:
-
-```php
-use Hypervel\Support\Number;
-
-$number = Number::format(100000);
-
-// 100,000
-
-$number = Number::format(100000, precision: 2);
-
-// 100,000.00
-
-$number = Number::format(100000.123, maxPrecision: 2);
-
-// 100,000.12
-
-$number = Number::format(100000, locale: 'de');
-
-// 100.000
-```
-
-
-#### `Number::ordinal()`
-
-The `Number::ordinal` method returns a number's ordinal representation:
-
-```php
-use Hypervel\Support\Number;
-
-$number = Number::ordinal(1);
-
-// 1st
-
-$number = Number::ordinal(2);
-
-// 2nd
-
-$number = Number::ordinal(21);
-
-// 21st
-```
-
-
-#### `Number::percentage()`
-
-The `Number::percentage` method returns the percentage representation of the given value as a string:
-
-```php
-use Hypervel\Support\Number;
-
-$percentage = Number::percentage(10);
-
-// 10%
-
-$percentage = Number::percentage(10, precision: 2);
-
-// 10.00%
-
-$percentage = Number::percentage(10.123, maxPrecision: 2);
-
-// 10.12%
-
-$percentage = Number::percentage(10, precision: 2, locale: 'de');
-
-// 10,00%
-```
-
-
-#### `Number::spell()`
-
-The `Number::spell` method transforms the given number into a string of words:
-
-```php
-use Hypervel\Support\Number;
-
-$number = Number::spell(102);
-
-// one hundred and two
-
-$number = Number::spell(88, locale: 'fr');
-
-// quatre-vingt-huit
-```
-
-The `after` argument allows you to specify a value after which all numbers should be spelled out:
-
-```php
-$number = Number::spell(10, after: 10);
-
-// 10
-
-$number = Number::spell(11, after: 10);
-
-// eleven
-```
-
-The `until` argument allows you to specify a value before which all numbers should be spelled out:
-
-```php
-$number = Number::spell(5, until: 10);
-
-// five
-
-$number = Number::spell(10, until: 10);
-
-// 10
-```
-
-
-#### `Number::useLocale()`
-
-The `Number::useLocale` method sets the default number locale globally, which affects how numbers and currency are formatted by subsequent invocations to the `Number` class's methods:
-
-```php
-use Hypervel\Support\Number;
-
-/**
- * Bootstrap any application services.
- */
-public function boot(): void
-{
- Number::useLocale('de');
-}
-```
-
-
-#### `Number::withLocale()`
-
-The `Number::withLocale` method executes the given closure using the specified locale and then restores the original locale after the callback has executed:
-
-```php
-use Hypervel\Support\Number;
-
-$number = Number::withLocale('de', function () {
- return Number::format(1500);
-});
-```
-
-
-## Paths
-
-
-#### `app_path()`
-
-The `app_path` function returns the fully qualified path to your application's `app` directory. You may also use the `app_path` function to generate a fully qualified path to a file relative to the application directory:
-
-```php
-$path = app_path();
-
-$path = app_path('Http/Controllers/Controller.php');
-```
-
-
-#### `base_path()`
-
-The `base_path` function returns the fully qualified path to your application's root directory. You may also use the `base_path` function to generate a fully qualified path to a given file relative to the project root directory:
-
-```php
-$path = base_path();
-
-$path = base_path('vendor/bin');
-```
-
-
-#### `config_path()`
-
-The `config_path` function returns the fully qualified path to your application's `config` directory. You may also use the `config_path` function to generate a fully qualified path to a given file within the application's configuration directory:
-
-```php
-$path = config_path();
-
-$path = config_path('app.php');
-```
-
-
-#### `database_path()`
-
-The `database_path` function returns the fully qualified path to your application's `database` directory. You may also use the `database_path` function to generate a fully qualified path to a given file within the database directory:
-
-```php
-$path = database_path();
-
-$path = database_path('factories/UserFactory.php');
-```
-
-
-#### `lang_path()`
-
-The `lang_path` function returns the fully qualified path to your application's `lang` directory. You may also use the `lang_path` function to generate a fully qualified path to a given file within the directory:
-
-```php
-$path = lang_path();
-
-$path = lang_path('en/messages.php');
-```
-
-
-#### `public_path()`
-
-The `public_path` function returns the fully qualified path to your application's `public` directory. You may also use the `public_path` function to generate a fully qualified path to a given file within the public directory:
-
-```php
-$path = public_path();
-
-$path = public_path('css/app.css');
-```
-
-
-#### `resource_path()`
-
-The `resource_path` function returns the fully qualified path to your application's `resources` directory. You may also use the `resource_path` function to generate a fully qualified path to a given file within the resources directory:
-
-```php
-$path = resource_path();
-
-$path = resource_path('sass/app.scss');
-```
-
-
-#### `storage_path()`
-
-The `storage_path` function returns the fully qualified path to your application's `storage` directory. You may also use the `storage_path` function to generate a fully qualified path to a given file within the storage directory:
-
-```php
-$path = storage_path();
-
-$path = storage_path('app/file.txt');
-```
-
-
-## URLs
-
-
-#### `asset()`
-
-The `asset` function generates a URL for an asset using the current scheme of the request (HTTP or HTTPS):
-
-```php
-$url = asset('img/photo.jpg');
-```
-
-You can configure the asset URL host by setting the `ASSET_URL` variable in your `.env` file. This can be useful if you host your assets on an external service like Amazon S3 or another CDN:
-
-```php
-// ASSET_URL=http://example.com/assets
-
-$url = asset('img/photo.jpg'); // http://example.com/assets/img/photo.jpg
-```
-
-
-#### `route()`
-
-The `route` function generates a URL for a given [named route](/docs/routing#named-routes):
-
-```php
-$url = route('route.name');
-```
-
-If the route accepts parameters, you may pass them as the second argument to the function:
-
-```php
-$url = route('route.name', ['id' => 1]);
-```
-
-By default, the `route` function generates an absolute URL. If you wish to generate a relative URL, you may pass `false` as the third argument to the function:
-
-```php
-$url = route('route.name', ['id' => 1], false);
-```
-
-
-#### `secure_asset()`
-
-The `secure_asset` function generates a URL for an asset using HTTPS:
-
-```php
-$url = secure_asset('img/photo.jpg');
-```
-
-
-#### `secure_url()`
-
-The `secure_url` function generates a fully qualified HTTPS URL to the given path. Additional URL segments may be passed in the function's second argument:
-
-```php
-$url = secure_url('user/profile');
-
-$url = secure_url('user/profile', [1]);
-```
-
-#### `to_route()`
-
-The `to_route` function generates a PSR response for a given [named route](/docs/routing#named-routes):
-
-```php
-return to_route('users.show', ['user' => 1]);
-```
-
-If necessary, you may pass the HTTP status code that should be assigned to the redirect and any additional response headers as the third and fourth arguments to the `to_route` method:
-
-```php
-return to_route('users.show', ['user' => 1], 302, ['X-Framework' => 'Hypervel']);
-```
-
-
-#### `url()`
-
-The `url` function generates a fully qualified URL to the given path:
-
- $url = url('user/profile');
-
- $url = url('user/profile', [1]);
-
-If no path is provided, an `Hypervel\Router\UrlGenerator` instance is returned:
-
- $current = url()->current();
-
- $full = url()->full();
-
- $previous = url()->previous();
-
-
-#### `url()`
-
-The `url` function generates a fully qualified URL to the given path:
-
-```php
-$url = url('user/profile');
-
-$url = url('user/profile', [1]);
-```
-
-If no path is provided, an `Hypervel\Router\UrlGenerator` instance is returned:
-
-```php
-$current = url()->current();
-
-$full = url()->full();
-
-$previous = url()->previous();
-```
-
-
-## Miscellaneous
-
-
-#### `abort()`
-
-The `abort` function throws [an HTTP exception](/docs/errors#http-exceptions) which will be rendered by the [exception handler](/docs/errors#the-exception-handler):
-
-```php
-abort(403);
-```
-
-You may also provide the exception's message and custom HTTP response headers that should be sent to the browser:
-
-```php
-abort(403, 'Unauthorized.', $headers);
-```
-
-
-#### `abort_if()`
-
-The `abort_if` function throws an HTTP exception if a given boolean expression evaluates to `true`:
-
-```php
-abort_if(! Auth::user()->isAdmin(), 403);
-```
-
-Like the `abort` method, you may also provide the exception's response text as the third argument and an array of custom response headers as the fourth argument to the function.
-
-
-#### `abort_unless()`
-
-The `abort_unless` function throws an HTTP exception if a given boolean expression evaluates to `false`:
-
-```php
-abort_unless(Auth::user()->isAdmin(), 403);
-```
-
-Like the `abort` method, you may also provide the exception's response text as the third argument and an array of custom response headers as the fourth argument to the function.
-
-
-#### `app()`
-
-The `app` function returns the [service container](/docs/container) instance:
-
-```php
-$container = app();
-```
-
-You may pass a class or interface name to resolve it from the container:
-
-```php
-$api = app('HelpSpot\API');
-```
-
-
-#### `auth()`
-
-The `auth` function returns an [authenticator](/docs/authentication) instance. You may use it as an alternative to the `Auth` facade:
-
-```php
-$user = auth()->user();
-```
-
-If needed, you may specify which guard instance you would like to access:
-
-```php
-$user = auth('admin')->user();
-```
-
-
-#### `bcrypt()`
-
-The `bcrypt` function [hashes](/docs/hashing) the given value using Bcrypt. You may use this function as an alternative to the `Hash` facade:
-
-```php
-$password = bcrypt('my-secret-password');
-```
-
-
-#### `blank()`
-
-The `blank` function determines whether the given value is "blank":
-
-```php
-blank('');
-blank(' ');
-blank(null);
-blank(collect());
-
-// true
-
-blank(0);
-blank(true);
-blank(false);
-
-// false
-```
-
-For the inverse of `blank`, see the [`filled`](#method-filled) method.
-
-
-#### `cache()`
-
-The `cache` function may be used to get values from the [cache](/docs/cache). If the given key does not exist in the cache, an optional default value will be returned:
-
-```php
-$value = cache('key');
-
-$value = cache('key', 'default');
-```
-
-You may add items to the cache by passing an array of key / value pairs to the function. You should also pass the number of seconds or duration the cached value should be considered valid:
-
-```php
-cache(['key' => 'value'], 300);
-
-cache(['key' => 'value'], now()->addSeconds(10));
-```
-
-
-#### `class_uses_recursive()`
-
-The `class_uses_recursive` function returns all traits used by a class, including traits used by all of its parent classes:
-
-```php
-$traits = class_uses_recursive(App\Models\User::class);
-```
-
-
-#### `collect()`
-
-The `collect` function creates a [collection](/docs/collections) instance from the given value:
-
-```php
-$collection = collect(['taylor', 'abigail']);
-```
-
-
-#### `config()`
-
-The `config` function gets the value of a [configuration](/docs/configuration) variable. The configuration values may be accessed using "dot" syntax, which includes the name of the file and the option you wish to access. A default value may be specified and is returned if the configuration option does not exist:
-
-```php
-$value = config('app.timezone');
-
-$value = config('app.timezone', $default);
-```
-
-You may set configuration variables at runtime by passing an array of key / value pairs. However, note that this function only affects the configuration value for the current request and does not update your actual configuration values:
-
-```php
-config(['app.debug' => true]);
-```
-
-
-#### `cookie()`
-
-The `cookie` function creates a new [cookie](/docs/requests#cookies) instance:
-
-```php
-$cookie = cookie('name', 'value', $minutes);
-```
-
-
-#### `decrypt()`
-
-The `decrypt` function [decrypts](/docs/encryption) the given value. You may use this function as an alternative to the `Crypt` facade:
-
-```php
-$password = decrypt($value);
-```
-
-
-#### `dd()`
-
-The `dd` function dumps the given variables and ends the execution of the script:
-
-```php
-dd($value);
-
-dd($value1, $value2, $value3, ...);
-```
-
-If you do not want to halt the execution of your script, use the [`dump`](#method-dump) function instead.
-
-
-#### `dispatch()`
-
-The `dispatch` function pushes the given [job](/docs/queues#creating-jobs) onto the Hypervel [job queue](/docs/queues):
-
-```php
-dispatch(new App\Jobs\SendEmails);
-```
-
-
-#### `dump()`
-
-The `dump` function dumps the given variables:
-
-```php
-dump($value);
-
-dump($value1, $value2, $value3, ...);
-```
-
-If you want to stop executing the script after dumping the variables, use the [`dd`](#method-dd) function instead.
-
-
-#### `encrypt()`
-
-The `encrypt` function [encrypts](/docs/encryption) the given value. You may use this function as an alternative to the `Crypt` facade:
-
-```php
-$secret = encrypt('my-secret-value');
-```
-
-
-#### `env()`
-
-The `env` function retrieves the value of an [environment variable](/docs/configuration#environment-configuration) or returns a default value:
-
-```php
-$env = env('APP_ENV');
-
-$env = env('APP_ENV', 'production');
-```
-
-::: warning
-If you execute the `config:cache` command during your deployment process, you should be sure that you are only calling the `env` function from within your configuration files. Once the configuration has been cached, the `.env` file will not be loaded and all calls to the `env` function will return `null`.
-:::
-
-
-#### `event()`
-
-The `event` function dispatches the given [event](/docs/events) to its listeners:
-
-```php
-event(new UserRegistered($user));
-```
-
-
-#### `filled()`
-
-The `filled` function determines whether the given value is not "blank":
-
-```php
-filled(0);
-filled(true);
-filled(false);
-
-// true
-
-filled('');
-filled(' ');
-filled(null);
-filled(collect());
-
-// false
-```
-
-For the inverse of `filled`, see the [`blank`](#method-blank) method.
-
-
-#### `info()`
-
-The `info` function will write information to your application's [log](/docs/logging):
-
-```php
-info('Some helpful information!');
-```
-
-An array of contextual data may also be passed to the function:
-
-```php
-info('User login attempt failed.', ['id' => $user->id]);
-```
-
-
-#### `logger()`
-
-The `logger` function can be used to write a `debug` level message to the [log](/docs/logging):
-
-```php
-logger('Debug message');
-```
-
-An array of contextual data may also be passed to the function:
-
-```php
-logger('User has logged in.', ['id' => $user->id]);
-```
-
-A [logger](/docs/errors#logging) instance will be returned if no value is passed to the function:
-
-```php
-logger()->error('You are not allowed here.');
-```
-
-
-#### `method_field()`
-
-The `method_field` function generates an HTML `hidden` input field containing the spoofed value of the form's HTTP verb. For example, using [Blade syntax](/docs/blade):
-
-```html
-
-```
-
-
-#### `now()`
-
-The `now` function creates a new `Hypervel\Support\Carbon` instance for the current time:
-
-```php
-$now = now();
-```
-
-
-#### `optional()`
-
-The `optional` function accepts any argument and allows you to access properties or call methods on that object. If the given object is `null`, properties and methods will return `null` instead of causing an error:
-
-```php
-return optional($user->address)->street;
-
-{!! old('name', optional($user)->name) !!}
-```
-
-The `optional` function also accepts a closure as its second argument. The closure will be invoked if the value provided as the first argument is not null:
-
-```php
-return optional(User::find($id), function (User $user) {
- return $user->name;
-});
-```
-
-
-#### `policy()`
-
-The `policy` method retrieves a [policy](/docs/authorization#creating-policies) instance for a given class:
-
-```php
-$policy = policy(App\Models\User::class);
-```
-
-
-#### `redirect()`
-
-The `redirect` function returns a [redirect HTTP response](/docs/responses#redirects), or returns the redirector instance if called with no arguments:
-
-```php
-return redirect($to = null, $status = 302, $headers = [], $https = null);
-
-return redirect('/home');
-
-return redirect()->route('route.name');
-```
-
-
-#### `report()`
-
-The `report` function will report an exception using your [exception handler](/docs/errors#the-exception-handler):
-
-```php
-report($e);
-```
-
-The `report` function also accepts a string as an argument. When a string is given to the function, the function will create an exception with the given string as its message:
-
-```php
-report('Something went wrong.');
-```
-
-
-#### `report_if()`
-
-The `report_if` function will report an exception using your [exception handler](/docs/errors#the-exception-handler) if the given condition is `true`:
-
-```php
-report_if($shouldReport, $e);
-
-report_if($shouldReport, 'Something went wrong.');
-```
-
-
-#### `report_unless()`
-
-The `report_unless` function will report an exception using your [exception handler](/docs/errors#the-exception-handler) if the given condition is `false`:
-
-```php
-report_unless($reportingDisabled, $e);
-
-report_unless($reportingDisabled, 'Something went wrong.');
-```
-
-
-#### `request()`
-
-The `request` function returns the current [request](/docs/requests) instance or obtains an input field's value from the current request:
-
-```php
-$request = request();
-
-$value = request('key', $default);
-```
-
-
-#### `rescue()`
-
-The `rescue` function executes the given closure and catches any exceptions that occur during its execution. All exceptions that are caught will be sent to your [exception handler](/docs/errors#the-exception-handler); however, the request will continue processing:
-
-```php
- return rescue(function () {
- return $this->method();
- });
-```
-
-You may also pass a second argument to the `rescue` function. This argument will be the "default" value that should be returned if an exception occurs while executing the closure:
-
-```php
-return rescue(function () {
- return $this->method();
-}, false);
-
-return rescue(function () {
- return $this->method();
-}, function () {
- return $this->failure();
-});
-```
-
-A `report` argument may be provided to the `rescue` function to determine if the exception should be reported via the `report` function:
-
-```php
-return rescue(function () {
- return $this->method();
-}, report: function (Throwable $throwable) {
- return $throwable instanceof InvalidArgumentException;
-});
-```
-
-
-#### `resolve()`
-
-The `resolve` function resolves a given class or interface name to an instance using the [service container](/docs/container):
-
-```php
-$api = resolve('HelpSpot\API');
-```
-
-
-#### `response()`
-
-The `response` function creates a [response](/docs/responses) instance or obtains an instance of the response factory:
-
-```php
-return response('Hello World', 200, $headers);
-
-return response()->json(['foo' => 'bar'], 200, $headers);
-```
-
-
-#### `retry()`
-
-The `retry` function attempts to execute the given callback until the given maximum attempt threshold is met. If the callback does not throw an exception, its return value will be returned. If the callback throws an exception, it will automatically be retried. If the maximum attempt count is exceeded, the exception will be thrown:
-
-```php
-return retry(5, function () {
- // Attempt 5 times while resting 100ms between attempts...
-}, 100);
-```
-
-If you would like to manually calculate the number of milliseconds to sleep between attempts, you may pass a closure as the third argument to the `retry` function:
-
-```php
-use Exception;
-
-return retry(5, function () {
- // ...
-}, function (int $attempt, Exception $exception) {
- return $attempt * 100;
-});
-```
-
-For convenience, you may provide an array as the first argument to the `retry` function. This array will be used to determine how many milliseconds to sleep between subsequent attempts:
-
-```php
-return retry([100, 200], function () {
- // Sleep for 100ms on first retry, 200ms on second retry...
-});
-```
-
-To only retry under specific conditions, you may pass a closure as the fourth argument to the `retry` function:
-
-```php
-use Exception;
-
-return retry(5, function () {
- // ...
-}, 100, function (Exception $exception) {
- return $exception instanceof RetryException;
-});
-```
-
-
-#### `session()`
-
-The `session` function may be used to get or set [session](/docs/session) values:
-
-```php
-$value = session('key');
-```
-
-You may set values by passing an array of key / value pairs to the function:
-
-```php
-session(['chairs' => 7, 'instruments' => 3]);
-```
-
-The session store will be returned if no value is passed to the function:
-
-```php
-$value = session()->get('key');
-
-session()->put('key', $value);
-```
-
-
-#### `tap()`
-
-The `tap` function accepts two arguments: an arbitrary `$value` and a closure. The `$value` will be passed to the closure and then be returned by the `tap` function. The return value of the closure is irrelevant:
-
-```php
-$user = tap(User::first(), function (User $user) {
- $user->name = 'taylor';
-
- $user->save();
-});
-```
-
-If no closure is passed to the `tap` function, you may call any method on the given `$value`. The return value of the method you call will always be `$value`, regardless of what the method actually returns in its definition. For example, the Eloquent `update` method typically returns an integer. However, we can force the method to return the model itself by chaining the `update` method call through the `tap` function:
-
-```php
-$user = tap($user)->update([
- 'name' => $name,
- 'email' => $email,
-]);
-```
-
-To add a `tap` method to a class, you may add the `Hypervel\Support\Traits\Tappable` trait to the class. The `tap` method of this trait accepts a Closure as its only argument. The object instance itself will be passed to the Closure and then be returned by the `tap` method:
-
-```php
-return $user->tap(function (User $user) {
- // ...
-});
-```
-
-
-#### `throw_if()`
-
-The `throw_if` function throws the given exception if a given boolean expression evaluates to `true`:
-
-```php
-throw_if(! Auth::user()->isAdmin(), AuthorizationException::class);
-
-throw_if(
- ! Auth::user()->isAdmin(),
- AuthorizationException::class,
- 'You are not allowed to access this page.'
-);
-```
-
-
-#### `throw_unless()`
-
-The `throw_unless` function throws the given exception if a given boolean expression evaluates to `false`:
-
-```php
-throw_unless(Auth::user()->isAdmin(), AuthorizationException::class);
-
-throw_unless(
- Auth::user()->isAdmin(),
- AuthorizationException::class,
- 'You are not allowed to access this page.'
-);
-```
-
-
-#### `today()`
-
-The `today` function creates a new `Hypervel\Support\Carbon` instance for the current date:
-
-```php
-$today = today();
-```
-
-
-#### `trait_uses_recursive()`
-
-The `trait_uses_recursive` function returns all traits used by a trait:
-
-```php
-$traits = trait_uses_recursive(\Hypervel\Notifications\Notifiable::class);
-```
-
-
-#### `transform()`
-
-The `transform` function executes a closure on a given value if the value is not [blank](#method-blank) and then returns the return value of the closure:
-
-```php
-$callback = function (int $value) {
- return $value * 2;
-};
-
-$result = transform(5, $callback);
-
-// 10
-```
-
-A default value or closure may be passed as the third argument to the function. This value will be returned if the given value is blank:
-
-```php
-$result = transform(null, $callback, 'The value is blank');
-
-// The value is blank
-```
-
-
-#### `validator()`
-
-The `validator` function creates a new [validator](/docs/validation) instance with the given arguments. You may use it as an alternative to the `Validator` facade:
-
-```php
-$validator = validator($data, $rules, $messages);
-```
-
-
-#### `value()`
-
-The `value` function returns the value it is given. However, if you pass a closure to the function, the closure will be executed and its returned value will be returned:
-
-```php
-$result = value(true);
-
-// true
-
-$result = value(function () {
- return false;
-});
-
-// false
-```
-
-Additional arguments may be passed to the `value` function. If the first argument is a closure then the additional parameters will be passed to the closure as arguments, otherwise they will be ignored:
-
-```php
-$result = value(function (string $name) {
- return $name;
-}, 'Taylor');
-
-// 'Taylor'
-```
-
-
-#### `view()`
-
-The `view` function retrieves a [view](/docs/views) instance:
-
-```php
-return view('auth.login');
-```
-
-
-#### `with()`
-
-The `with` function returns the value it is given. If a closure is passed as the second argument to the function, the closure will be executed and its returned value will be returned:
-
-```php
-$callback = function (mixed $value) {
- return is_numeric($value) ? $value * 2 : 0;
-};
-
-$result = with(5, $callback);
-
-// 10
-
-$result = with(null, $callback);
-
-// 0
-
-$result = with(5, null);
-
-// 5
-```
-
-## Other Utilities
-
-### Dates
-
-Hypervel includes [Carbon](https://carbon.nesbot.com/docs/), a powerful date and time manipulation library. To create a new `Carbon` instance, you may invoke the `now` function. This function is globally available within your Hypervel application:
-
-```php
-$now = now();
-```
-
-Or, you may create a new `Carbon` instance using the `Hypervel\Support\Carbon` class:
-
-```php
-use Hypervel\Support\Carbon;
-
-$now = Carbon::now();
-```
-
-For a thorough discussion of Carbon and its features, please consult the [official Carbon documentation](https://carbon.nesbot.com/docs/).
-
-### Pipeline
-
-Hypervel's `Pipeline` provides a convenient way to "pipe" a given input through a series of invokable classes, closures, or callables, giving each class the opportunity to inspect or modify the input and invoke the next callable in the pipeline:
-
-```php
-use Closure;
-use App\Models\User;
-use Hypervel\Support\Pipeline;
-
-$user = Pipeline::make()
- ->send($user)
- ->through([
- function (User $user, Closure $next) {
- // ...
-
- return $next($user);
- },
- function (User $user, Closure $next) {
- // ...
-
- return $next($user);
- },
- ])
- ->then(fn (User $user) => $user);
-```
-
-As you can see, each invokable class or closure in the pipeline is provided the input and a `$next` closure. Invoking the `$next` closure will invoke the next callable in the pipeline. As you may have noticed, this is very similar to [middleware](/docs/middleware).
-
-When the last callable in the pipeline invokes the `$next` closure, the callable provided to the `then` method will be invoked. Typically, this callable will simply return the given input.
-
-Of course, as discussed previously, you are not limited to providing closures to your pipeline. You may also provide invokable classes. If a class name is provided, the class will be instantiated via Hypervel's [service container](/docs/container), allowing dependencies to be injected into the invokable class:
-
-```php
-$user = Pipeline::make()
- ->send($user)
- ->through([
- GenerateProfilePhoto::class,
- ActivateSubscription::class,
- SendWelcomeEmail::class,
- ])
- ->then(fn (User $user) => $user);
-```
-
-### Sleep
-
-Hypervel's `Sleep` class is a light-weight wrapper around PHP's native `sleep` and `usleep` functions, offering greater testability while also exposing a developer friendly API for working with time:
-
-```php
-use Hypervel\Support\Sleep;
-
-$waiting = true;
-
-while ($waiting) {
- Sleep::for(1)->second();
-
- $waiting = /* ... */;
-}
-```
-
-The `Sleep` class offers a variety of methods that allow you to work with different units of time:
-
-```php
-// Return a value after sleeping...
-$result = Sleep::for(1)->second()->then(fn () => 1 + 1);
-
-// Sleep while a given value is true...
-Sleep::for(1)->second()->while(fn () => shouldKeepSleeping());
-
-// Pause execution for 90 seconds...
-Sleep::for(1.5)->minutes();
-
-// Pause execution for 2 seconds...
-Sleep::for(2)->seconds();
-
-// Pause execution for 500 milliseconds...
-Sleep::for(500)->milliseconds();
-
-// Pause execution for 5,000 microseconds...
-Sleep::for(5000)->microseconds();
-
-// Pause execution until a given time...
-Sleep::until(now()->addMinute());
-
-// Alias of PHP's native "sleep" function...
-Sleep::sleep(2);
-
-// Alias of PHP's native "usleep" function...
-Sleep::usleep(5000);
-```
-
-To easily combine units of time, you may use the `and` method:
-
-```php
-Sleep::for(1)->second()->and(10)->milliseconds();
-```
-
-#### Testing Sleep
-
-When testing code that utilizes the `Sleep` class or PHP's native sleep functions, your test will pause execution. As you might expect, this makes your test suite significantly slower. For example, imagine you are testing the following code:
-
-```php
-$waiting = /* ... */;
-
-$seconds = 1;
-
-while ($waiting) {
- Sleep::for($seconds++)->seconds();
-
- $waiting = /* ... */;
-}
-```
-
-Typically, testing this code would take at least one second. Luckily, the `Sleep` class allows us to "fake" sleeping so that our test suite stays fast:
-
-```php
-public function testItWaitsUntilReady()
-{
- Sleep::fake();
-
- // ...
-}
-```
-
-When faking the `Sleep` class, the actual execution pause is bypassed, leading to a substantially faster test.
-
-Once the `Sleep` class has been faked, it is possible to make assertions against the expected "sleeps" that should have occurred. To illustrate this, let's imagine we are testing code that pauses execution three times, with each pause increasing by a single second. Using the `assertSequence` method, we can assert that our code "slept" for the proper amount of time while keeping our test fast:
-
-```php
-public function testItChecksIfReadyThreeTimes()
-{
- Sleep::fake();
-
- // ...
-
- Sleep::assertSequence([
- Sleep::for(1)->second(),
- Sleep::for(2)->seconds(),
- Sleep::for(3)->seconds(),
- ]);
-}
-```
-
-Of course, the `Sleep` class offers a variety of other assertions you may use when testing:
-
-```php
-use Carbon\CarbonInterval as Duration;
-use Hypervel\Support\Sleep;
-
-// Assert that sleep was called 3 times...
-Sleep::assertSleptTimes(3);
-
-// Assert against the duration of sleep...
-Sleep::assertSlept(function (Duration $duration): bool {
- return /* ... */;
-}, times: 1);
-
-// Assert that the Sleep class was never invoked...
-Sleep::assertNeverSlept();
-
-// Assert that, even if Sleep was called, no execution paused occurred...
-Sleep::assertInsomniac();
-```
-
-Sometimes it may be useful to perform an action whenever a fake sleep occurs. To achieve this, you may provide a callback to the `whenFakingSleep` method. In the following example, we use Hypervel's [time manipulation helpers](/docs/mocking#interacting-with-time) to instantly progress time by the duration of each sleep:
-
-```php
-use Carbon\CarbonInterval as Duration;
-
-$this->freezeTime();
-
-Sleep::fake();
-
-Sleep::whenFakingSleep(function (Duration $duration) {
- // Progress time when faking sleep...
- $this->travel($duration->totalMilliseconds)->milliseconds();
-});
-```
-
-As progressing time is a common requirement, the fake method accepts a `syncWithCarbon` argument to keep Carbon in sync when sleeping within a test:
-
-```php
-Sleep::fake(syncWithCarbon: true);
-
-$start = now();
-
-Sleep::for(1)->second();
-
-$start->diffForHumans(); // 1 second ago
-```
-
-Hypervel uses the `Sleep` class internally whenever it is pausing execution. For example, the [retry](/docs/helpers#method-retry) helper uses the `Sleep` class when sleeping, allowing for improved testability when using that helper.
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/horizon.md b/_archive/docs/0.3/docs/horizon.md
deleted file mode 100644
index e693e9418e..0000000000
--- a/_archive/docs/0.3/docs/horizon.md
+++ /dev/null
@@ -1,660 +0,0 @@
-# Hypervel Horizon
-[[toc]]
-
-## Introduction
-
-::: note
-Before digging into Hypervel Horizon, you should familiarize yourself with Hypervel's base [queue services](/docs/queues). Horizon augments Hypervel's queue with additional features that may be confusing if you are not already familiar with the basic queue features offered by Hypervel.
-:::
-
-[Hypervel Horizon](https://github.com/hypervel/horizon) provides a beautiful dashboard and code-driven configuration for your Hypervel powered [Redis queues](/docs/queues). Horizon allows you to easily monitor key metrics of your queue system such as job throughput, runtime, and job failures.
-
-When using Horizon, all of your queue worker configuration is stored in a single, simple configuration file. By defining your application's worker configuration in a version controlled file, you may easily scale or modify your application's queue workers when deploying your application.
-
-
-
-## Installation
-
-::: warning
-Hypervel Horizon requires that you use [Redis](https://redis.io) to power your queue. Therefore, you should ensure that your queue connection is set to `redis` in your application's `config/queue.php` configuration file.
-:::
-
-You may install Horizon into your project using the Composer package manager:
-
-```shell
-composer require hypervel/horizon
-```
-
-After installing Horizon, publish its assets using the `horizon:install` Artisan command:
-
-```shell
-php artisan horizon:install
-```
-
-### Configuration
-
-After publishing Horizon's assets, its primary configuration file will be located at `config/horizon.php`. This configuration file allows you to configure the queue worker options for your application. Each configuration option includes a description of its purpose, so be sure to thoroughly explore this file.
-
-::: warning
-Horizon uses a Redis connection named `horizon` internally. This Redis connection name is reserved and should not be assigned to another Redis connection in the `database.php` configuration file or as the value of the `use` option in the `horizon.php` configuration file.
-:::
-
-#### Environments
-
-After installation, the primary Horizon configuration option that you should familiarize yourself with is the `environments` configuration option. This configuration option is an array of environments that your application runs on and defines the worker process options for each environment. By default, this entry contains a `production` and `local` environment. However, you are free to add more environments as needed:
-
-```php
-'environments' => [
- 'production' => [
- 'supervisor-1' => [
- 'maxProcesses' => 10,
- 'balanceMaxShift' => 1,
- 'balanceCooldown' => 3,
- ],
- ],
-
- 'local' => [
- 'supervisor-1' => [
- 'maxProcesses' => 3,
- ],
- ],
-],
-```
-
-You may also define a wildcard environment (`*`) which will be used when no other matching environment is found:
-
-```php
-'environments' => [
- // ...
-
- '*' => [
- 'supervisor-1' => [
- 'maxProcesses' => 3,
- ],
- ],
-],
-```
-
-When you start Horizon, it will use the worker process configuration options for the environment that your application is running on. Typically, the environment is determined by the value of the `APP_ENV` [environment variable](/docs/configuration#determining-the-current-environment). For example, the default `local` Horizon environment is configured to start three worker processes and automatically balance the number of worker processes assigned to each queue. The default `production` environment is configured to start a maximum of 10 worker processes and automatically balance the number of worker processes assigned to each queue.
-
-::: warning
-You should ensure that the `environments` portion of your `horizon` configuration file contains an entry for each [environment](/docs/configuration#environment-configuration) on which you plan to run Horizon.
-:::
-
-#### Supervisors
-
-As you can see in Horizon's default configuration file, each environment can contain one or more "supervisors". By default, the configuration file defines this supervisor as `supervisor-1`; however, you are free to name your supervisors whatever you want. Each supervisor is essentially responsible for "supervising" a group of worker processes and takes care of balancing worker processes across queues.
-
-You may add additional supervisors to a given environment if you would like to define a new group of worker processes that should run in that environment. You may choose to do this if you would like to define a different balancing strategy or worker process count for a given queue used by your application.
-
-#### Default Values
-
-Within Horizon's default configuration file, you will notice a `defaults` configuration option. This configuration option specifies the default values for your application's [supervisors](#supervisors). The supervisor's default configuration values will be merged into the supervisor's configuration for each environment, allowing you to avoid unnecessary repetition when defining your supervisors.
-
-### Dashboard Authorization
-
-The Horizon dashboard may be accessed via the `/horizon` route. By default, you will only be able to access this dashboard in the `local` environment. However, within your `app/Providers/HorizonServiceProvider.php` file, there is an [authorization gate](/docs/authorization#gates) definition. This authorization gate controls access to Horizon in **non-local** environments. You are free to modify this gate as needed to restrict access to your Horizon installation:
-
-```php
-/**
- * Register the Horizon gate.
- *
- * This gate determines who can access Horizon in non-local environments.
- */
-protected function gate(): void
-{
- Gate::define('viewHorizon', function (User $user) {
- return in_array($user->email, [
- 'taylor@Hypervel.com',
- ]);
- });
-}
-```
-
-#### Alternative Authentication Strategies
-
-Remember that Hypervel automatically injects the authenticated user into the gate closure. If your application is providing Horizon security via another method, such as IP restrictions, then your Horizon users may not need to "login". Therefore, you will need to change `function (User $user)` closure signature above to `function (User $user = null)` in order to force Hypervel to not require authentication.
-
-### Max Job Attempts
-
-::: note
-Before refining these options, make sure you are familiar with Hypervel's default [queue services](/docs/queues#max-job-attempts-and-timeout) and the concept of 'attempts'.
-:::
-
-You can define the maximum number of attempts a job can consume within a supervisor's configuration:
-
-```php
-'environments' => [
- 'production' => [
- 'supervisor-1' => [
- // ...
- 'tries' => 10,
- ],
- ],
-],
-```
-
-::: note
-This option is similar to the `--tries` option when using the Artisan command to process queues.
-:::
-
-Adjusting the `tries` option is essential when using middlewares such as `WithoutOverlapping` or `RateLimited` because they consume attempts. To handle this, adjust the `tries` configuration value either at the supervisor level or by defining the `$tries` property on the job class.
-
-If you don't set the `tries` option, Horizon defaults to a single attempt, unless the job class defines `$tries`, which takes precedence over the Horizon configuration.
-
-Setting `tries` or `$tries` to 0 allows unlimited attempts, which is ideal when the number of attempts is uncertain. To prevent endless failures, you can limit the number of exceptions allowed by setting the `$maxExceptions` property on the job class.
-
-### Job Timeout
-
-Similarly, you can set a `timeout` value at the supervisor level, which specifies how many seconds a worker process can run a job before it's forcefully terminated. Once terminated, the job will either be retried or marked as failed, depending on your queue configuration:
-
-```php
-'environments' => [
- 'production' => [
- 'supervisor-1' => [
- // ...¨
- 'timeout' => 60,
- ],
- ],
-],
-```
-
-::: warning
-When using the `auto` balancing strategy, Horizon will consider in-progress workers as "hanging" and force-kill them after the Horizon timeout during scale down. Always ensure the Horizon timeout is greater than any job-level timeout, otherwise jobs may be terminated mid-execution. In addition, the `timeout` value should always be at least a few seconds shorter than the `retry_after` value defined in your `config/queue.php` configuration file. Otherwise, your jobs may be processed twice.
-:::
-
-### Job Backoff
-
-You can define the `backoff` value at the supervisor level to specify how long Horizon should wait before retrying a job that encounters an unhandled exception:
-
-```php
-'environments' => [
- 'production' => [
- 'supervisor-1' => [
- // ...
- 'backoff' => 10,
- ],
- ],
-],
-```
-
-You may also configure "exponential" backoffs by using an array for the `backoff` value. In this example, the retry delay will be 1 second for the first retry, 5 seconds for the second retry, 10 seconds for the third retry, and 10 seconds for every subsequent retry if there are more attempts remaining:
-
-```php
-'environments' => [
- 'production' => [
- 'supervisor-1' => [
- // ...
- 'backoff' => [1, 5, 10],
- ],
- ],
-],
-```
-
-### Silenced Jobs
-
-Sometimes, you may not be interested in viewing certain jobs dispatched by your application or third-party packages. Instead of these jobs taking up space in your "Completed Jobs" list, you can silence them. To get started, add the job's class name to the `silenced` configuration option in your application's `horizon` configuration file:
-
-```php
-'silenced' => [
- App\Jobs\ProcessPodcast::class,
-],
-```
-
-In addition to silencing individual job classes, Horizon also supports silencing jobs based on [tags](#tags). This can be useful if you want to hide multiple jobs that share a common tag:
-
-```php
-'silenced_tags' => [
- 'notifications'
-],
-```
-
-Alternatively, the job you wish to silence can implement the `Hypervel\Horizon\Contracts\Silenced` interface. If a job implements this interface, it will automatically be silenced, even if it is not present in the `silenced` configuration array:
-
-```php
-use Hypervel\Horizon\Contracts\Silenced;
-
-class ProcessPodcast implements ShouldQueue, Silenced
-{
- use Queueable;
-
- // ...
-}
-```
-
-## Balancing Strategies
-
-Each supervisor can process one or more queues but unlike Hypervel's default queue system, Horizon allows you to choose from three worker balancing strategies: `auto`, `simple`, and `false`.
-
-::: important
-Unlike Laravel, Hypervel's Queue Worker has native concurrency capabilities. In traditional Laravel, even when handling multiple I/O-bound tasks, you need multiple workers to achieve concurrency and avoid blocking. However, in Hypervel, you can easily specify the concurrency level for each worker through the `--concurrency` parameter, which utilizes coroutines for concurrent execution.
-
-This means that what previously required 10 worker processes in Laravel to achieve a certain level of concurrency can now be accomplished in Hypervel with just a single worker by controlling the number of concurrent coroutines through the `concurrency` parameter!
-
-```php
-php artisan horizon:supervisor --concurrency=10
-```
-
-> If you have 10 workers and set the concurrency to 10, this means you can have a total concurrency capacity of 100.
-:::
-
-### Auto Balancing
-
-The `auto` strategy, which is the default strategy, adjusts the number of worker processes per queue based on the current workload of the queue. For example, if your `notifications` queue has 1,000 pending jobs while your `default` queue is empty, Horizon will allocate more workers to your `notifications` queue until the queue is empty.
-
-When using the `auto` strategy, you may also configure the `minProcesses` and `maxProcesses` configuration options:
-
-
-
-- `minProcesses` defines the minimum number of worker processes per queue. This value must be greater than or equal to 1.
-- `maxProcesses` defines the maximum total number of worker processes Horizon may scale up to across all queues. This value should typically be greater than the number of queues multiplied by the `minProcesses` value. To prevent the supervisor from spawning any processes, you may set this value to 0.
-
-
-
-For example, you may configure Horizon to maintain at least one process per queue and scale up to a total of 10 worker processes:
-
-```php
-'environments' => [
- 'production' => [
- 'supervisor-1' => [
- 'connection' => 'redis',
- 'queue' => ['default', 'notifications'],
- 'balance' => 'auto',
- 'autoScalingStrategy' => 'time',
- 'minProcesses' => 1,
- 'maxProcesses' => 10,
- 'balanceMaxShift' => 1,
- 'balanceCooldown' => 3,
- ],
- ],
-],
-```
-
-The `autoScalingStrategy` configuration option determines how Horizon will assign more worker processes to queues. You can choose between two strategies:
-
-
-
-- The `time` strategy will assign workers based on the total estimated amount of time it will take to clear the queue.
-- The `size` strategy will assign workers based on the total number of jobs on the queue.
-
-
-
-The `balanceMaxShift` and `balanceCooldown` configuration values determine how quickly Horizon will scale to meet worker demand. In the example above, a maximum of one new process will be created or destroyed every three seconds. You are free to tweak these values as necessary based on your application's needs.
-
-#### Queue Priorities and Auto Balancing
-
-When using the `auto` balancing strategy, Horizon does not enforce strict priority between queues. The order of queues in a supervisor's configuration does not affect how worker processes are assigned. Instead, Horizon relies on the selected `autoScalingStrategy` to dynamically allocate worker processes based on queue load.
-
-For example, in the following configuration, the high queue is not prioritized over the default queue, despite appearing first in the list:
-
-```php
-'environments' => [
- 'production' => [
- 'supervisor-1' => [
- // ...
- 'queue' => ['high', 'default'],
- 'minProcesses' => 1,
- 'maxProcesses' => 10,
- ],
- ],
-],
-```
-
-If you need to enforce a relative priority between queues, you may define multiple supervisors and explicitly allocate processing resources:
-
-```php
-'environments' => [
- 'production' => [
- 'supervisor-1' => [
- // ...
- 'queue' => ['default'],
- 'minProcesses' => 1,
- 'maxProcesses' => 10,
- ],
- 'supervisor-2' => [
- // ...
- 'queue' => ['images'],
- 'minProcesses' => 1,
- 'maxProcesses' => 1,
- ],
- ],
-],
-```
-
-In this example, the default `queue` can scale up to 10 processes, while the `images` queue is limited to one process. This configuration ensures that your queues can scale independently.
-
-::: note
-When dispatching resource-intensive jobs, it's sometimes best to assign them to a dedicated queue with a limited `maxProcesses` value. Otherwise, these jobs could consume excessive CPU resources and overload your system.
-:::
-
-### Simple Balancing
-
-The `simple` strategy distributes worker processes evenly across the specified queues. With this strategy, Horizon does not automatically scale the number of worker processes. Rather, it uses a fixed number of processes:
-
-```php
-'environments' => [
- 'production' => [
- 'supervisor-1' => [
- // ...
- 'queue' => ['default', 'notifications'],
- 'balance' => 'simple',
- 'processes' => 10,
- ],
- ],
-],
-```
-
-In the example above, Horizon will assign 5 processes to each queue, splitting the total of 10 evenly.
-
-If you'd like to control the number of worker processes assigned to each queue individually, you can define multiple supervisors:
-
-```php
-'environments' => [
- 'production' => [
- 'supervisor-1' => [
- // ...
- 'queue' => ['default'],
- 'balance' => 'simple',
- 'processes' => 10,
- ],
- 'supervisor-notifications' => [
- // ...
- 'queue' => ['notifications'],
- 'balance' => 'simple',
- 'processes' => 2,
- ],
- ],
-],
-```
-
-With this configuration, Horizon will assign 10 processes to the `default` queue and 2 processes to the `notifications` queue.
-
-### No Balancing
-
-When the `balance` option is set to `false`, Horizon processes queues strictly in the order they're listed, similar to Hypervel's default queue system. However, it will still scale the number of worker processes if jobs begin to accumulate:
-
-```php
-'environments' => [
- 'production' => [
- 'supervisor-1' => [
- // ...
- 'queue' => ['default', 'notifications'],
- 'balance' => false,
- 'minProcesses' => 1,
- 'maxProcesses' => 10,
- ],
- ],
-],
-```
-
-In the example above, jobs in the `default` queue are always prioritized over jobs in the `notifications` queue. For instance, if there are 1,000 jobs in `default` and only 10 in `notifications`, Horizon will fully process all `default` jobs before handling any from `notifications`.
-
-You can control Horizon's ability to scale worker processes using the `minProcesses` and `maxProcesses` options:
-
-
-
-- `minProcesses` defines the minimum number of worker processes in total. This value must be greater than or equal to 1.
-- `maxProcesses` defines the maximum total number of worker processes Horizon may scale up to.
-
-
-
-## Running Horizon
-
-Once you have configured your supervisors and workers in your application's `config/horizon.php` configuration file, you may start Horizon using the `horizon` Artisan command. This single command will start all of the configured worker processes for the current environment:
-
-```shell
-php artisan horizon
-```
-
-You may pause the Horizon process and instruct it to continue processing jobs using the `horizon:pause` and `horizon:continue` Artisan commands:
-
-```shell
-php artisan horizon:pause
-
-php artisan horizon:continue
-```
-
-You may also pause and continue specific Horizon [supervisors](#supervisors) using the `horizon:pause-supervisor` and `horizon:continue-supervisor` Artisan commands:
-
-```shell
-php artisan horizon:pause-supervisor supervisor-1
-
-php artisan horizon:continue-supervisor supervisor-1
-```
-
-You may check the current status of the Horizon process using the `horizon:status` Artisan command:
-
-```shell
-php artisan horizon:status
-```
-
-You may check the current status of a specific Horizon [supervisor](#supervisors) using the `horizon:supervisor-status` Artisan command:
-
-```shell
-php artisan horizon:supervisor-status supervisor-1
-```
-
-You may gracefully terminate the Horizon process using the `horizon:terminate` Artisan command. Any jobs that are currently being processed will be completed and then Horizon will stop executing:
-
-```shell
-php artisan horizon:terminate
-```
-
-### Deploying Horizon
-
-When you're ready to deploy Horizon to your application's actual server, you should configure a process monitor to monitor the `php artisan horizon` command and restart it if it exits unexpectedly. Don't worry, we'll discuss how to install a process monitor below.
-
-During your application's deployment process, you should instruct the Horizon process to terminate so that it will be restarted by your process monitor and receive your code changes:
-
-```shell
-php artisan horizon:terminate
-```
-
-#### Installing Supervisor
-
-Supervisor is a process monitor for the Linux operating system and will automatically restart your `horizon` process if it stops executing. To install Supervisor on Ubuntu, you may use the following command. If you are not using Ubuntu, you can likely install Supervisor using your operating system's package manager:
-
-```shell
-sudo apt-get install supervisor
-```
-
-#### Supervisor Configuration
-
-Supervisor configuration files are typically stored within your server's `/etc/supervisor/conf.d` directory. Within this directory, you may create any number of configuration files that instruct supervisor how your processes should be monitored. For example, let's create a `horizon.conf` file that starts and monitors a `horizon` process:
-
-```ini
-[program:horizon]
-process_name=%(program_name)s
-command=php /home/forge/example.com/artisan horizon
-autostart=true
-autorestart=true
-user=forge
-redirect_stderr=true
-stdout_logfile=/home/forge/example.com/horizon.log
-stopwaitsecs=3600
-```
-
-When defining your Supervisor configuration, you should ensure that the value of `stopwaitsecs` is greater than the number of seconds consumed by your longest running job. Otherwise, Supervisor may kill the job before it is finished processing.
-
-::: warning
-While the examples above are valid for Ubuntu based servers, the location and file extension expected of Supervisor configuration files may vary between other server operating systems. Please consult your server's documentation for more information.
-:::
-
-#### Starting Supervisor
-
-Once the configuration file has been created, you may update the Supervisor configuration and start the monitored processes using the following commands:
-
-```shell
-sudo supervisorctl reread
-
-sudo supervisorctl update
-
-sudo supervisorctl start horizon
-```
-
-::: note
-For more information on running Supervisor, consult the [Supervisor documentation](http://supervisord.org/index.html).
-:::
-
-## Tags
-
-Horizon allows you to assign "tags" to jobs, including mailables, broadcast events, notifications, and queued event listeners. In fact, Horizon will intelligently and automatically tag most jobs depending on the Eloquent models that are attached to the job. For example, take a look at the following job:
-
-```php
-
- */
- public function tags(): array
- {
- return ['render', 'video:'.$this->video->id];
- }
-}
-```
-
-#### Manually Tagging Event Listeners
-
-When retrieving the tags for a queued event listener, Horizon will automatically pass the event instance to the `tags` method, allowing you to add event data to the tags:
-
-```php
-class SendRenderNotifications implements ShouldQueue
-{
- /**
- * Get the tags that should be assigned to the listener.
- *
- * @return array
-
-[assertCookie](#assert-cookie)
-[assertCookieExpired](#assert-cookie-expired)
-[assertCookieNotExpired](#assert-cookie-not-expired)
-[assertCookieMissing](#assert-cookie-missing)
-[assertCreated](#assert-created)
-[assertDontSee](#assert-dont-see)
-[assertDontSeeText](#assert-dont-see-text)
-[assertExactJson](#assert-exact-json)
-[assertForbidden](#assert-forbidden)
-[assertHeader](#assert-header)
-[assertHeaderMissing](#assert-header-missing)
-[assertJson](#assert-json)
-[assertJsonCount](#assert-json-count)
-[assertJsonFragment](#assert-json-fragment)
-[assertJsonMissing](#assert-json-missing)
-[assertJsonMissingExact](#assert-json-missing-exact)
-[assertJsonMissingValidationErrors](#assert-json-missing-validation-errors)
-[assertJsonPath](#assert-json-path)
-[assertJsonStructure](#assert-json-structure)
-[assertJsonValidationErrors](#assert-json-validation-errors)
-[assertLocation](#assert-location)
-[assertNoContent](#assert-no-content)
-[assertNotFound](#assert-not-found)
-[assertOk](#assert-ok)
-[assertPlainCookie](#assert-plain-cookie)
-[assertRedirect](#assert-redirect)
-[assertSee](#assert-see)
-[assertSeeInOrder](#assert-see-in-order)
-[assertSeeText](#assert-see-text)
-[assertSeeTextInOrder](#assert-see-text-in-order)
-[assertSessionHas](#assert-session-has)
-[assertSessionHasInput](#assert-session-has-input)
-[assertSessionHasAll](#assert-session-has-all)
-[assertSessionHasErrors](#assert-session-has-errors)
-[assertSessionHasErrorsIn](#assert-session-has-errors-in)
-[assertSessionHasNoErrors](#assert-session-has-no-errors)
-[assertSessionDoesntHaveErrors](#assert-session-doesnt-have-errors)
-[assertSessionMissing](#assert-session-missing)
-[assertStatus](#assert-status)
-[assertSuccessful](#assert-successful)
-[assertUnauthorized](#assert-unauthorized)
-
-
-
-#### assertCookie
-
-Assert that the response contains the given cookie:
-
-```php
-$response->assertCookie($cookieName, $value = null);
-```
-
-#### assertCookieExpired
-
-Assert that the response contains the given cookie and it is expired:
-
-```php
-$response->assertCookieExpired($cookieName);
-```
-
-#### assertCookieNotExpired
-
-Assert that the response contains the given cookie and it is not expired:
-
-```php
-$response->assertCookieNotExpired($cookieName);
-```
-
-#### assertCookieMissing
-
-Assert that the response does not contains the given cookie:
-
-```php
-$response->assertCookieMissing($cookieName);
-```
-
-#### assertCreated
-
-Assert that the response has a 201 status code:
-
-```php
-$response->assertCreated();
-```
-
-#### assertDontSee
-
-Assert that the given string is not contained within the response. This assertion will automatically escape the given string unless you pass a second argument of `false`:
-
-```php
-$response->assertDontSee($value, $escaped = true);
-```
-
-#### assertDontSeeText
-
-Assert that the given string is not contained within the response text. This assertion will automatically escape the given string unless you pass a second argument of `false`:
-
-```php
-$response->assertDontSeeText($value, $escaped = true);
-```
-
-#### assertExactJson
-
-Assert that the response contains an exact match of the given JSON data:
-
-```php
-$response->assertExactJson(array $data);
-```
-
-#### assertForbidden
-
-Assert that the response has a forbidden (403) status code:
-
-```php
-$response->assertForbidden();
-```
-
-#### assertHeader
-
-Assert that the given header is present on the response:
-
-```php
-$response->assertHeader($headerName, $value = null);
-```
-
-#### assertHeaderMissing
-
-Assert that the given header is not present on the response:
-
-```php
-$response->assertHeaderMissing($headerName);
-```
-
-#### assertJson
-
-Assert that the response contains the given JSON data:
-
-```php
-$response->assertJson(array $data, $strict = false);
-```
-
-#### assertJsonCount
-
-Assert that the response JSON has an array with the expected number of items at the given key:
-
-```php
-$response->assertJsonCount($count, $key = null);
-```
-
-#### assertJsonFragment
-
-Assert that the response contains the given JSON fragment:
-
-```php
-$response->assertJsonFragment(array $data);
-```
-
-#### assertJsonMissing
-
-Assert that the response does not contain the given JSON fragment:
-
-```php
-$response->assertJsonMissing(array $data);
-```
-
-#### assertJsonMissingExact
-
-Assert that the response does not contain the exact JSON fragment:
-
-```php
-$response->assertJsonMissingExact(array $data);
-```
-
-#### assertJsonMissingValidationErrors
-
-Assert that the response has no JSON validation errors for the given keys:
-
-```php
-$response->assertJsonMissingValidationErrors($keys);
-```
-
-#### assertJsonPath
-
-Assert that the response contains the given data at the specified path:
-
-```php
-$response->assertJsonPath($path, array $data, $strict = false);
-```
-
-#### assertJsonStructure
-
-Assert that the response has a given JSON structure:
-
-```php
-$response->assertJsonStructure(array $structure);
-```
-
-#### assertJsonValidationErrors
-
-Assert that the response has the given JSON validation errors:
-
-```php
-$response->assertJsonValidationErrors(array $data);
-```
-
-#### assertLocation
-
-Assert that the response has the given URI value in the `Location` header:
-
-```php
-$response->assertLocation($uri);
-```
-
-#### assertNoContent
-
-Assert that the response has the given status code and no content.
-
-```php
-$response->assertNoContent($status = 204);
-```
-
-#### assertNotFound
-
-Assert that the response has a not found status code:
-
-```php
-$response->assertNotFound();
-```
-
-#### assertOk
-
-Assert that the response has a 200 status code:
-
-```php
-$response->assertOk();
-```
-
-#### assertPlainCookie
-
-Assert that the response contains the given cookie (unencrypted):
-
-```php
-$response->assertPlainCookie($cookieName, $value = null);
-```
-
-#### assertRedirect
-
-Assert that the response is a redirect to a given URI:
-
-```php
-$response->assertRedirect($uri);
-```
-
-#### assertSee
-
-Assert that the given string is contained within the response. This assertion will automatically escape the given string unless you pass a second argument of `false`:
-
-```php
-$response->assertSee($value, $escaped = true);
-```
-
-#### assertSeeInOrder
-
-Assert that the given strings are contained in order within the response. This assertion will automatically escape the given strings unless you pass a second argument of `false`:
-
-```php
-$response->assertSeeInOrder(array $values, $escaped = true);
-```
-
-#### assertSeeText
-
-Assert that the given string is contained within the response text. This assertion will automatically escape the given string unless you pass a second argument of `false`:
-
-```php
-$response->assertSeeText($value, $escaped = true);
-```
-
-#### assertSeeTextInOrder
-
-Assert that the given strings are contained in order within the response text. This assertion will automatically escape the given strings unless you pass a second argument of `false`:
-
-```php
-$response->assertSeeTextInOrder(array $values, $escaped = true);
-```
-
-#### assertSessionHas
-
-Assert that the session contains the given piece of data:
-
-```php
-$response->assertSessionHas($key, $value = null);
-```
-
-#### assertSessionHasInput
-
-Assert that the session has a given value in the flashed input array:
-
-```php
-$response->assertSessionHasInput($key, $value = null);
-```
-
-#### assertSessionHasAll
-
-Assert that the session has a given list of values:
-
-```php
-$response->assertSessionHasAll(array $data);
-```
-
-#### assertSessionHasErrors
-
-Assert that the session contains an error for the given `$keys`. If `$keys` is an associative array, assert that the session contains a specific error message (value) for each field (key):
-
-```php
-$response->assertSessionHasErrors(array $keys, $format = null, $errorBag = ```
-'default');
-```
-
-#### assertSessionHasErrorsIn
-
-Assert that the session contains an error for the given `$keys`, within a specific error bag. If `$keys` is an associative array, assert that the session contains a specific error message (value) for each field (key), within the error bag:
-
-```php
-$response->assertSessionHasErrorsIn($errorBag, $keys = [], $format = null);
-```
-
-#### assertSessionHasNoErrors
-
-Assert that the session has no errors:
-
-```php
-$response->assertSessionHasNoErrors();
-```
-
-#### assertSessionDoesntHaveErrors
-
-Assert that the session has no errors for the given keys:
-
-```php
-$response->assertSessionDoesntHaveErrors($keys = [], $format = null, $errorBag ```
-= 'default');
-
-#### assertSessionMissing
-
-Assert that the session does not contain the given key:
-
-```php
-$response->assertSessionMissing($key);
-```
-
-#### assertStatus
-
-Assert that the response has a given code:
-
-```php
-$response->assertStatus($code);
-```
-
-#### assertSuccessful
-
-Assert that the response has a successful (>= 200 and < 300) status code:
-
-```php
-$response->assertSuccessful();
-```
-
-#### assertUnauthorized
-
-Assert that the response has an unauthorized (401) status code:
-
-```php
-$response->assertUnauthorized();
-```
-
-### Authentication Assertions
-
-Hypervel also provides a variety of authentication related assertions for your [PHPUnit](https://phpunit.de/) feature tests:
-
-Method | Description
-------------- | -------------
-`$this->assertAuthenticated($guard = null);` | Assert that the user is authenticated.
-`$this->assertGuest($guard = null);` | Assert that the user is not authenticated.
-`$this->assertAuthenticatedAs($user, $guard = null);` | Assert that the given user is authenticated.
-`$this->assertCredentials(array $credentials, $guard = null);` | Assert that the given credentials are valid.
-`$this->assertInvalidCredentials(array $credentials, $guard = null);` | Assert that the given credentials are invalid.
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/installation.md b/_archive/docs/0.3/docs/installation.md
deleted file mode 100644
index 4c731196a7..0000000000
--- a/_archive/docs/0.3/docs/installation.md
+++ /dev/null
@@ -1,129 +0,0 @@
-# Installation
-[[toc]]
-
-## Creating a Hypervel Project
-
-Before creating your first Hypervel project, make sure that your local machine has [Composer](https://getcomposer.org/) installed for dependencies management, and the Swoole PHP extension must be installed as well. Typically, this can be done via PECL:
-
-```shell:no-line-numbers
-pecl install swoole
-```
-
-Mac users can also install Swoole via brew:
-
-```shell:no-line-numbers
-brew tap shivammathur/extensions
-brew install shivammathur/extensions/swoole@8.3
-```
-
-> Using `shivammathur/extensions` can help you solve common issues while installing swoole on Apple M1 environments. Please substitute the PHP version with the end of extension formula.
-
-::: info
-You can also use [Box](https://hyperf.wiki/3.1/#/en/eco/box.md) as your runtime environment.
-:::
-
-::: tip
-It's recommended to set `swoole.use_shortname` to `Off` in your `php.ini` file for catching errors in coroutines if you plan to use global coroutine helpers such as `go`, `co` and `defer`. Otherwise it will throw `Uncaught RuntimeException` when errors in coroutines are not properly caught.
-
-See [Wrong Way to Handle Throwables](/docs/coroutine#error-handling-in-coroutines) for more information.
-:::
-
-After you have installed PHP, Composer and Swoole extension, you may create a new Hypervel project via Composer's `create-project` command:
-
-```shell:no-line-numbers
-composer create-project hypervel/hypervel example-app
-```
-
-Once the project has been created, start Hypervel's local development server using serve command:
-
-```shell:no-line-numbers
-cd example-app
-
-php artisan serve
-```
-
-Because all the files will be kept in the memory after running, you need to restart server after you make file changes. In development, you can use hot reload command:
-
-```shell:no-line-numbers
-php artisan watch
-```
-
-Once you have started the HTTP server, your application will be accessible in your web browser at [http://localhost:9501](http://localhost:9501). Next, you're ready to start taking your next steps into Hypervel.
-
-::: tip
-You can customize your `host` and `port` and other server options in `config/server.php`.
-:::
-
-## Initial Configuration
-
-All of the configuration files for the Hypervel are stored in the config directory. Each option is documented, so feel free to look through the files and get familiar with the options available to you.
-
-You may wish to review the `config/app.php` file and its documentation. It contains several options such as `timezone` and `locale` that you may wish to change according to your application.
-
-## Environment Based Configuration
-
-Since many of Hypervel's configuration option values may vary depending on whether your application is running on your local machine or on a production web server, many important configuration values are defined using the `.env` file that exists at the root of your application.
-
-Your `.env` file should not be committed to your application's source control, since each developer / server using your application could require a different environment configuration. Furthermore, this would be a security risk in the event an intruder gains access to your source control repository, since any sensitive credentials would be exposed.
-
-::: note
-For more information about the `.env` file and environment based configuration, check out the full [configuration documentation](/docs/configuration#environment-configuration).
-:::
-
-## Databases and Migrations
-
-Now that you have created your Hypervel application, you probably want to store some data in a database. By default, your application's `.env` configuration file specifies that Laravel will be interacting with a SQLite database.
-
-During the creation of the project, Laravel created a `database/database.sqlite` file for you, and ran the necessary migrations to create the application's database tables.
-
-If you prefer to use another database driver such as MySQL, you can update your `.env` configuration file to use the appropriate database. For example, if you wish to use MySQL, update your `.env` configuration file's `DB_*` variables like so:
-
-```shell:no-line-numbers
-DB_CONNECTION=mysql
-DB_HOST=127.0.0.1
-DB_PORT=3306
-DB_DATABASE=laravel_hyperf
-DB_USERNAME=root
-DB_PASSWORD=
-```
-
-If you choose to use a database other than SQLite, you will need to create the database and run your application's [database migrations](/docs/migrations):
-
-```shell:no-line-numbers
-php artisan migrate
-```
-
-## Developing with Docker
-
-If your environment doesn't meet Hypervel's requirements or you're unfamiliar with system configuration, you can develop your Hypervel project using Docker:
-
-- Run Container
-
-In the following example the host will be mapped to the local directory `/workspace/hypervel`:
-
-::: note
-If the `selinux-enabled` option is enabled when docker starts, access to host resources in the container will be restricted, so you should add the `--privileged -u root` option when starting the container.
-:::
-
-```shell:no-line-numbers
-docker run --name hypervel \
--v /workspace/hypervel:/data/project \
--p 9501:9501 -it \
---privileged -u root \
---entrypoint /bin/sh \
-hyperf/hyperf:8.3-alpine-v3.19-swoole-v6
-```
-
-::: note
-If docker's selinux-enabled option is on, add `--privileged -u root` to the command.
-:::
-
-## Incompatible extensions
-
-Because Hypervel is based on Swoole's coroutine functionality, some extensions are incompatible in the coroutine environment. The following (including but not limited to) extensions are currently incompatible:
-
-- xhprof
-- xdebug (It's available in PHP 8.1+ and Swoole >= 5.0.2)
-- blackfire
-- trace
-- uopz
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/introduction.md b/_archive/docs/0.3/docs/introduction.md
deleted file mode 100644
index db5fb89620..0000000000
--- a/_archive/docs/0.3/docs/introduction.md
+++ /dev/null
@@ -1,227 +0,0 @@
-## Introduction
-
-**Hypervel** is a Laravel-style PHP framework with native coroutine support for ultra-high performance.
-
-Hypervel ports many core components from Laravel while maintaining familiar usage patterns, making it instantly accessible to Laravel developers. The framework combines the elegant and expressive development experience of Laravel with the powerful performance benefits of coroutine-based programming. If you're a Laravel developer, you'll feel right at home with this framework, requiring minimal learning curve.
-
-This is an ideal choice for building microservices, API gateways, and high-concurrency applications where traditional PHP frameworks often encounter performance constraints.
-
-## Why Hypervel?
-
-While Laravel Octane impressively enhances your Laravel application's performance, it's crucial to understand the nature of modern web applications. In most cases, the majority of latency stems from I/O operations, such as file operations, database queries, and API requests.
-
-However, Laravel doesn't support coroutines - the entire framework is designed for a blocking I/O environment. Applications heavily dependent on I/O operations will still face performance bottlenecks. Consider this scenario:
-
-Imagine building an AI-powered chatbot where each conversation API takes 3-5 seconds to respond. With 10 workers in Laravel Octane receiving 10 concurrent requests, all workers would be blocked until these requests complete.
-
-For I/O-intensive scenarios, even with Laravel Octane's improvements, your application's ability to handle concurrent requests is still limited by the duration of these I/O operations. Hypervel addresses this issue by leveraging coroutines, allowing for efficient handling of concurrent I/O operations without blocking workers. This approach can significantly improve the performance and concurrency of applications with heavy I/O requirements.
-
-Moreover, it's unlikely that Laravel Octane will support coroutines in the near future (see [this issue](https://github.com/laravel/octane/issues/765)), given that only Swoole runtime currently supports this feature and considering backward compatibility with the framework and third-party packages.
-
-::: important
-Even if Laravel Octane supported coroutines, these coroutines would still be limited to a single request, with workers remaining blocked until all I/O operations within that request completed. That means your Laravel application can't get better QPS results in this kind of scenario.
-
-See [this pull request](https://github.com/swoole/swoole-src/pull/4330) for more information.
-:::
-
-## Laravel Octane
-
-Laravel is renowned for its expressive and elegant syntax, powerful package ecosystem, and thriving community. However, due to the traditional lifecycle in PHP-FPM, Laravel's performance is limited despite various optimization techniques applied to the framework.
-
-At LaraCon 2021, Taylor Otwell announced Laravel Octane — a first-party package maintained by the Laravel team. Octane significantly enhances Laravel application performance by running your code in a long-lived process on high-powered application servers such as Swoole, RoadRunner, and FrankenPHP.
-
-> For more information, see [Laravel Octane](https://laravel.com/docs/master/octane).
-
-## Hyperf
-
-Hypervel is built on the Hyperf ecosystem, similar to how Laravel relates to Symfony. Hyperf is a high-performance framework powered by Swoole and Swow, with all components natively supporting coroutines and strictly adhering to PSR standards. It allows developers to easily build high-concurrency applications with built-in support for non-blocking I/O.
-
-The Hyperf project maintains high activity levels on GitHub, with regular feature updates and version releases. This demonstrates strong community engagement and consistent development progress. With over 6,000 stars on GitHub and more than 350 contributors since 2019, Hyperf is a top choice for developers seeking a modern web framework to build high-performance PHP projects with asynchronous I/O support.
-
-> For more details, visit [Hyperf's official website](https://hyperf.io/).
-
-## Benchmark
-
-The benchmark tests cover two distinct scenarios to evaluate performance under different conditions:
-
-1. Simple API Test:
- - A basic `hello world` API endpoint
- - No middleware applied
- - Tests raw response speed
-
-2. Simulated I/O Wait Test:
- - Sleep for one second to simulate I/O wait time
- - Respond with `hello world` after the delay
- - Tests performance under I/O-bound conditions
-
-> worker numbers are configured as CPU cores by default
-
-Test Environment Specifications:
-- Hardware: Apple M1 Pro 2021
-- CPU: 8 cores
-- RAM: 16 GB
-
-### Simple API Test
-
-* Laravel Octane (8 workers)
-
-```text:no-line-numbers
-Running 10s test @ http://127.0.0.1:8000/api
- 4 threads and 100 connections
- Thread Stats Avg Stdev Max +/- Stdev
- Latency 15.93ms 16.86ms 155.82ms 87.02%
- Req/Sec 2.07k 420.46 3.10k 66.00%
- 82661 requests in 10.04s, 16.95MB read
-Requests/sec: 8230.97
-Transfer/sec: 1.69MB
-```
-
-* Hypervel (8 workers)
-
-```text:no-line-numbers
-Running 10s test @ http://127.0.0.1:9501/api
- 4 threads and 100 connections
- Thread Stats Avg Stdev Max +/- Stdev
- Latency 7.66ms 17.85ms 249.92ms 90.25%
- Req/Sec 24.42k 10.47k 54.37k 68.53%
- 971692 requests in 10.06s, 151.98MB read
-Requests/sec: 96562.80
-Transfer/sec: 15.10MB
-```
-
-::: chart
-
-```json
-{
- "type": "bar",
- "data": {
- "labels": ["Hello World API"],
- "datasets": [
- {
- "label": "Laravel Octane",
- "data": [8230.97],
- "backgroundColor": "rgba(255, 182, 193, 0.8)",
- "borderColor": "rgba(255, 182, 193, 1)",
- "borderWidth": 1
- },
- {
- "label": "Hypervel",
- "data": [96562.80],
- "backgroundColor": "rgba(173, 216, 230, 0.8)",
- "borderColor": "rgba(173, 216, 230, 1)",
- "borderWidth": 1
- }
- ]
- },
- "options": {
- "responsive": true,
- "scales": {
- "x": {
- "stacked": false
- },
- "y": {
- "stacked": false,
- "title": {
- "display": true,
- "text": "QPS"
- }
- }
- },
- "plugins": {
- "title": {
- "display": true,
- "text": "Laravel Octane vs Hypervel"
- },
- "legend": {
- "position": "top"
- }
- }
- }
-}
-```
-:::
-
-### Simulated I/O Wait Test
-
-* Laravel Octane (8 workers)
-
-```text:no-line-numbers
-Running 10s test @ http://127.0.0.1:8000/api
- 4 threads and 100 connections
- Thread Stats Avg Stdev Max +/- Stdev
- Latency 1.03s 184.92us 1.03s 87.50%
- Req/Sec 1.52 1.29 5.00 54.84%
- 80 requests in 10.10s, 16.80KB read
- Socket errors: connect 0, read 0, write 0, timeout 72
-Requests/sec: 7.92
-Transfer/sec: 1.66KB
-```
-
-* Hypervel (8 workers)
-
-```text:no-line-numbers
-Running 10s test @ http://10.10.4.12:9501/api
- 16 threads and 15000 connections
- Thread Stats Avg Stdev Max +/- Stdev
- Latency 1.02s 64.72ms 1.87s 93.62%
- Req/Sec 1.16k 1.68k 9.15k 87.59%
- 109401 requests in 10.09s, 19.82MB read
-Requests/sec: 10842.71
-Transfer/sec: 1.96MB
-```
-
-> In this case I run wrk in another machine to make sure wrk can use as much resource for keeping more connections.
-
-::: chart
-
-```json
-{
- "type": "bar",
- "data": {
- "labels": ["1s wait I/O"],
- "datasets": [
- {
- "label": "Laravel Octane",
- "data": [7.92],
- "backgroundColor": "rgba(255, 182, 193, 0.8)",
- "borderColor": "rgba(255, 182, 193, 1)",
- "borderWidth": 1
- },
- {
- "label": "Hypervel",
- "data": [10842.71],
- "backgroundColor": "rgba(173, 216, 230, 0.8)",
- "borderColor": "rgba(173, 216, 230, 1)",
- "borderWidth": 1
- }
- ]
- },
- "options": {
- "responsive": true,
- "scales": {
- "x": {
- "stacked": false
- },
- "y": {
- "stacked": false,
- "title": {
- "display": true,
- "text": "QPS"
- }
- }
- },
- "plugins": {
- "title": {
- "display": true,
- "text": "Laravel Octane vs Hypervel"
- },
- "legend": {
- "position": "top"
- }
- }
- }
-}
-```
-:::
-
-> Laravel Octane's QPS number is close to 8, but because it differs so significantly from Hypervel's numbers, it appears this way when generated in the chart.
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/lifecycle.md b/_archive/docs/0.3/docs/lifecycle.md
deleted file mode 100644
index a1ecb7f27d..0000000000
--- a/_archive/docs/0.3/docs/lifecycle.md
+++ /dev/null
@@ -1,60 +0,0 @@
-# Lifecycle
-[[toc]]
-
-## Introduction
-
-When using any tool in the "real world", you feel more confident if you understand how that tool works. Application development is no different. When you understand how your development tools function, you feel more comfortable and confident using them.
-
-The goal of this document is to give you a good, high-level overview of how Hypervel works. By getting to know the overall framework better, everything feels less "magical" and you will be more confident building your applications. If you don't understand all of the terms right away, don't lose heart! Just try to get a basic grasp of what is going on, and your knowledge will grow as you explore other sections of the documentation.
-
-## Lifecycle Overview
-
-### First Steps
-
-The entry point for all requests to a Hypervel application is the `artisan` file. The `artisan` file doesn't contain much code. Rather, it is a starting point for loading the rest of the framework.
-
-The `artisan` file loads the Composer generated autoloader definition and environment variables, and then retrieves an instance of the Hypervel application from `bootstrap/app.php`. The first action taken by Hypervel itself is to create an instance of the application / [service container](/docs/container).
-
-::: note
-`BASE_PATH` constant is defined in `artisan`. Although we suggest fetching base path from service container, components in Hyperf framework have strong coupling to `BASE_PATH` constant. Therefore you can still find `BASE_PATH` in Hypervel for backward compatibility.
-:::
-
-### Container Bindings
-
-Same as in Laravel, the application itself is a service container. When the application created, dependencies scanner collected container bindings from `config/dependencies.php`. This is how dependencies are registered in Hyperf by default. Hypervel also supports registering dependencies in service providers.
-
-### Console Kernel
-
-Next, the console kernel defines an array of `bootstrappers` that will be run before executing the command. These bootstrappers load facade aliases, register service providers, load commands and setup cronjob scheduling. Typically, these classes handle internal Hypervel configurations that you do not need to worry about.
-
-### Config Providers / Service Providers
-
-Config Providers (from Hyperf framework) are similar to Laravel's `Service Providers`. Config Providers will provide all the configuration information of the corresponding components, which will be started by Hypervel when loaded. Essentially every major feature offered by Hypervel is bootstrapped and configured by config providers.
-
-Hypervel also supports [service providers](/docs/providers) in a manner similar to Laravel. Service providers are responsible for bootstrapping the framework's various components and are a fundamental part of the Hypervel application lifecycle.
-
-Hypervel will iterate through this list of providers and instantiate each of them. After instantiating the providers, the `register` method will be called on all of the providers. Then, once all of the providers have been registered, the `boot` method will be called on each provider. This is so service providers may depend on every container binding being registered and available by the time their `boot` method is executed.
-
-While the framework internally uses dozens of Config Providers / Service Providers, you also have the option to create your own. If you're going to create a third-party package, we recommend using `Config Provider` or providing both `Config Provider` and `Service Provider` to ensure compatibility of Hyperf framework.
-
-### Routing
-
-Once the application has been bootstrapped and all service providers have been registered, an HTTP server will be launched and wait for incoming requests.
-
-The `Request` will be handed off to the router for dispatching. The router will dispatch the request to a route or controller, as well as run any route specific middleware.
-
-Middleware provide a convenient mechanism for filtering or examining HTTP requests entering your application. For example, Hypervel includes a middleware that verifies if the user of your application is authenticated. If the user is not authenticated, it will throw `AuthenticationException`. You can set up your middleware in a Laravel style by configuring `app/Http/Kernel.php`. To learn more about middleware, you can refer to the complete [middleware documentation](/docs/middleware).
-
-If the request successfully passes through all of the matched route's assigned middleware, the route or controller method will be executed. The response returned by the route or controller method will then be sent back through the route's chain of middleware. This allows middleware to perform actions both before and after your core application logic executes.
-
-Middleware in Hypervel can filter requests, modify responses, and even terminate the request cycle entirely if necessary. By configuring middleware in `app/Http/Kernel.php`, you can define global middleware, assign middleware to specific routes, or create middleware groups for convenient assignment.
-
-For more detailed information on creating, registering, and using middleware in Hypervel, including examples and best practices, please refer to the [middleware documentation](/docs/middleware).
-
-## Focus on Config Providers / Service Providers
-
-Config Providers / Service providers are truly the key to bootstrapping a Hypervel application. The application instance is created, the service providers are registered, and the request is handed to the bootstrapped application. It's really that simple!
-
-Having a firm grasp of how a Hypervel application is built and bootstrapped via service providers is very valuable. Your application's user-defined service providers are stored in the `app/Providers` directory.
-
-By default, the `AppServiceProvider` is fairly empty. This provider is a great place to add your application's own bootstrapping and service container bindings. For large applications, you may wish to create several service providers, each with more granular bootstrapping for specific services used by your application.
diff --git a/_archive/docs/0.3/docs/localization.md b/_archive/docs/0.3/docs/localization.md
deleted file mode 100644
index 9508e0bc68..0000000000
--- a/_archive/docs/0.3/docs/localization.md
+++ /dev/null
@@ -1,199 +0,0 @@
-# Localization
-[[toc]]
-
-## Introduction
-
-Hypervel's localization features provide a convenient way to retrieve strings in various languages, allowing you to easily support multiple languages within your application.
-
-Hypervel provides two ways to manage translation strings. First, language strings may be stored in files within the application's `lang` directory. Within this directory, there may be subdirectories for each language supported by the application. This is the approach Hypervel uses to manage translation strings for built-in Hypervel features such as validation error messages:
-
-```plaintext:no-line-numbers
-/lang
- /en
- messages.php
- /es
- messages.php
-```
-
-Or, translation strings may be defined within JSON files that are placed within the `lang` directory. When taking this approach, each language supported by your application would have a corresponding JSON file within this directory. This approach is recommended for applications that have a large number of translatable strings:
-
-```plaintext:no-line-numbers
-/lang
- en.json
- es.json
-```
-
-We'll discuss each approach to managing translation strings within this documentation.
-
-### Configuring the Locale
-
-The default language for your application is stored in the `config/app.php` configuration file's `locale` configuration option. You are free to modify this value to suit the needs of your application.
-
-You may also configure a "fallback language", which will be used when the default language does not contain a given translation string. Like the default language, the fallback language is also configured in the `config/app.php` configuration file, and its value is typically set using the `APP_FALLBACK_LOCALE` environment variable.
-
-You may modify the default language for a single HTTP request at runtime using the `setLocale` method provided by the `App` facade:
-
-```php
-use Hypervel\Support\Facades\App;
-
-Route::get('/greeting/{locale}', function (string $locale) {
- if (! in_array($locale, ['en', 'es', 'fr'])) {
- abort(400);
- }
-
- App::setLocale($locale);
-
- // ...
-});
-```
-
-You may configure a "fallback language", which will be used when the active language does not contain a given translation string. Like the default language, the fallback language is also configured in the `config/app.php` configuration file:
-
-```php
-'fallback_locale' => 'en',
-```
-
-#### Determining the Current Locale
-
-You may use the `currentLocale` and `isLocale` methods on the `App` facade to determine the current locale or check if the locale is a given value:
-
-```php
-use Hypervel\Support\Facades\App;
-
-$locale = App::currentLocale();
-
-if (App::isLocale('en')) {
- // ...
-}
-```
-
-## Defining Translation Strings
-
-### Using Short Keys
-
-Typically, translation strings are stored in files within the `lang` directory. Within this directory, there should be a subdirectory for each language supported by your application. This is the approach Hypervel uses to manage translation strings for built-in Hypervel features such as validation error messages:
-
-```plaintext:no-line-numbers
-/lang
- /en
- messages.php
- /es
- messages.php
-```
-
-All language files return an array of keyed strings. For example:
-
-```php
- 'Welcome to our application!',
-];
-```
-
-::: warning
-For languages that differ by territory, you should name the language directories according to the ISO 15897. For example, "en_GB" should be used for British English rather than "en-gb".
-:::
-
-### Using Translation Strings as Keys
-
-For applications with a large number of translatable strings, defining every string with a "short key" can become confusing when referencing the keys in your views and it is cumbersome to continually invent keys for every translation string supported by your application.
-
-For this reason, Laravel also provides support for defining translation strings using the "default" translation of the string as the key. Language files that use translation strings as keys are stored as JSON files in the `lang` directory. For example, if your application has a Spanish translation, you should create a `lang/es.json` file:
-
-```json
-{
- "I love programming.": "Me encanta programar."
-}
-```
-
-#### Key / File Conflicts
-
-You should not define translation string keys that conflict with other translation filenames. For example, translating `__('Action')` for the "NL" locale while a `nl/action.php` file exists but a `nl.json` file does not exist will result in the translator returning the entire contents of `nl/action.php`.
-
-## Retrieving Translation Strings
-
-You may retrieve translation strings from your language files using the `__` helper function. If you are using "short keys" to define your translation strings, you should pass the file that contains the key and the key itself to the `__` function using "dot" syntax. For example, let's retrieve the `welcome` translation string from the `lang/en/messages.php` language file:
-
-```php
-echo __('messages.welcome');
-```
-
-If the specified translation string does not exist, the `__` function will return the translation string key. So, using the example above, the `__` function would return `messages.welcome` if the translation string does not exist.
-
-If you are using the [Blade templating engine](/docs/blade), you may use the `{{ }}` echo syntax to display the translation string:
-
-```php
-{{ __('messages.welcome') }}
-```
-
-### Replacing Parameters in Translation Strings
-
-If you wish, you may define placeholders in your translation strings. All placeholders are prefixed with a `:`. For example, you may define a welcome message with a placeholder name:
-
-```php
-'welcome' => 'Welcome, :name',
-```
-
-To replace the placeholders when retrieving a translation string, you may pass an array of replacements as the second argument to the `__` function:
-
-```php
-echo __('messages.welcome', ['name' => 'dayle']);
-```
-
-If your placeholder contains all capital letters, or only has its first letter capitalized, the translated value will be capitalized accordingly:
-
-```php
-'welcome' => 'Welcome, :NAME', // Welcome, DAYLE
-'goodbye' => 'Goodbye, :Name', // Goodbye, Dayle
-```
-
-### Pluralization
-
-Pluralization is a complex problem, as different languages have a variety of complex rules for pluralization; however, Hypervel can help you translate strings differently based on pluralization rules that you define. Using a `|` character, you may distinguish singular and plural forms of a string:
-
-```php
-'apples' => 'There is one apple|There are many apples',
-```
-
-Of course, pluralization is also supported when using [translation strings as keys](#using-translation-strings-as-keys):
-
-```json
-{
- "There is one apple|There are many apples": "Hay una manzana|Hay muchas manzanas"
-}
-```
-
-You may even create more complex pluralization rules which specify translation strings for multiple ranges of values:
-
-```php
-'apples' => '{0} There are none|[1,19] There are some|[20,*] There are many',
-```
-
-After defining a translation string that has pluralization options, you may use the `trans_choice` function to retrieve the line for a given "count". In this example, since the count is greater than one, the plural form of the translation string is returned:
-
-```php
-echo trans_choice('messages.apples', 10);
-```
-
-You may also define placeholder attributes in pluralization strings. These placeholders may be replaced by passing an array as the third argument to the `trans_choice` function:
-
-```php
-'minutes_ago' => '{1} :value minute ago|[2,*] :value minutes ago',
-
-echo trans_choice('time.minutes_ago', 5, ['value' => 5]);
-```
-
-If you would like to display the integer value that was passed to the `trans_choice` function, you may use the built-in `:count` placeholder:
-
-```php
-'apples' => '{0} There are none|{1} There is one|[2,*] There are :count',
-```
-
-## Overriding Package Language Files
-
-Some packages may ship with their own language files. Instead of changing the package's core files to tweak these lines, you may override them by placing files in the `lang/vendor/{package}/{locale}` directory.
-
-So, for example, if you need to override the English translation strings in `messages.php` for a package named `skyrim/hearthfire`, you should place a language file at: `lang/vendor/hearthfire/en/messages.php`. Within this file, you should only define the translation strings you wish to override. Any translation strings you don't override will still be loaded from the package's original language files.
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/logging.md b/_archive/docs/0.3/docs/logging.md
deleted file mode 100644
index 956f929997..0000000000
--- a/_archive/docs/0.3/docs/logging.md
+++ /dev/null
@@ -1,475 +0,0 @@
-# Logging
-[[toc]]
-
-## Introduction
-
-To help you learn more about what's happening within your application, Hypervel provides robust logging services that allow you to log messages to files, the system error log, and even to Slack to notify your entire team.
-
-Hypervel's logging is based on "channels". Each channel represents a specific way of writing log information. For example, the `single` channel writes log files to a single log file, while the `slack` channel sends log messages to Slack. Log messages may be written to multiple channels based on their severity.
-
-Under the hood, Hypervel utilizes the [Monolog](https://github.com/Seldaek/monolog) library, which provides support for a variety of powerful log handlers. Hypervel makes it a cinch to configure these handlers, allowing you to mix and match them to customize your application's log handling.
-
-## Configuration
-
-All of the configuration options for your application's logging behavior are housed in the `config/logging.php` configuration file. This file allows you to configure your application's log channels, so be sure to review each of the available channels and their options. We'll review a few common options below.
-
-By default, Hypervel will use the `stack` channel when logging messages. The `stack` channel is used to aggregate multiple log channels into a single channel. For more information on building stacks, check out the [documentation below](#building-log-stacks).
-
-#### Configuring the Channel Name
-
-By default, Monolog is instantiated with a "channel name" that matches the current environment, such as `production` or `local`. To change this value, add a `name` option to your channel's configuration:
-
-```php
-'stack' => [
- 'driver' => 'stack',
- 'name' => 'channel-name',
- 'channels' => ['single', 'slack'],
-],
-```
-
-### Available Channel Drivers
-
-Each log channel is powered by a "driver". The driver determines how and where the log message is actually recorded. The following log channel drivers are available in every Hypervel application. An entry for most of these drivers is already present in your application's `config/logging.php` configuration file, so be sure to review this file to become familiar with its contents:
-
-
-
-Name | Description
-------------- | -------------
-`custom` | A driver that calls a specified factory to create a channel
-`daily` | A `RotatingFileHandler` based Monolog driver which rotates daily
-`errorlog` | An `ErrorLogHandler` based Monolog driver
-`monolog` | A Monolog factory driver that may use any supported Monolog handler
-`papertrail` | A `SyslogUdpHandler` based Monolog driver
-`single` | A single file or path based logger channel (`StreamHandler`)
-`slack` | A `SlackWebhookHandler` based Monolog driver
-`stack` | A wrapper to facilitate creating "multi-channel" channels
-`syslog` | A `SyslogHandler` based Monolog driver
-
-
-
-::: note
-Check out the documentation on [advanced channel customization](#monolog-channel-customization) to learn more about the `monolog` and `custom` drivers.
-:::
-
-### Channel Prerequisites
-
-#### Configuring the Single and Daily Channels
-
-The `single` and `daily` channels have three optional configuration options: `bubble`, `permission`, and `locking`.
-
-
-
-Name | Description | Default
-------------- | ------------- | -------------
-`bubble` | Indicates if messages should bubble up to other channels after being handled | `true`
-`locking` | Attempt to lock the log file before writing to it | `false`
-`permission` | The log file's permissions | `0644`
-
-
-
-Additionally, the retention policy for the `daily` channel can be configured via the `days` option:
-
-
-
-Name | Description | Default
-------------- |-------------------------------------------------------------------| -------------
-`days` | The number of days that daily log files should be retained | `7`
-
-
-
-#### Configuring the Papertrail Channel
-
-The `papertrail` channel requires the `host` and `port` configuration options. You can obtain these values from [Papertrail](https://help.papertrailapp.com/kb/configuration/configuring-centralized-logging-from-php-apps/#send-events-from-php-app).
-
-#### Configuring the Slack Channel
-
-The `slack` channel requires a `url` configuration option. This URL should match a URL for an [incoming webhook](https://slack.com/apps/A0F7XDUAZ-incoming-webhooks) that you have configured for your Slack team.
-
-By default, Slack will only receive logs at the `critical` level and above; however, you can adjust this in your `config/logging.php` configuration file by modifying the `level` configuration option within your Slack log channel's configuration array.
-
-### Logging Deprecation Warnings
-
-PHP, Hypervel, and other libraries often notify their users that some of their features have been deprecated and will be removed in a future version. If you would like to log these deprecation warnings, you may specify your preferred `deprecations` log channel in your application's `config/logging.php` configuration file:
-
-```php
-'deprecations' => env('LOG_DEPRECATIONS_CHANNEL', 'null'),
-
-'channels' => [
- ...
-]
-```
-
-Or, you may define a log channel named `deprecations`. If a log channel with this name exists, it will always be used to log deprecations:
-
-```php
-'channels' => [
- 'deprecations' => [
- 'driver' => 'single',
- 'path' => storage_path('logs/php-deprecation-warnings.log'),
- ],
-],
-```
-
-## Building Log Stacks
-
-As mentioned previously, the `stack` driver allows you to combine multiple channels into a single log channel for convenience. To illustrate how to use log stacks, let's take a look at an example configuration that you might see in a production application:
-
-```php
-'channels' => [
- 'stack' => [
- 'driver' => 'stack',
- 'channels' => ['syslog', 'slack'],
- ],
-
- 'syslog' => [
- 'driver' => 'syslog',
- 'level' => 'debug',
- ],
-
- 'slack' => [
- 'driver' => 'slack',
- 'url' => env('LOG_SLACK_WEBHOOK_URL'),
- 'username' => 'Hypervel Log',
- 'emoji' => ':boom:',
- 'level' => 'critical',
- ],
-],
-```
-
-Let's dissect this configuration. First, notice our `stack` channel aggregates two other channels via its `channels` option: `syslog` and `slack`. So, when logging messages, both of these channels will have the opportunity to log the message. However, as we will see below, whether these channels actually log the message may be determined by the message's severity / "level".
-
-#### Log Levels
-
-Take note of the `level` configuration option present on the `syslog` and `slack` channel configurations in the example above. This option determines the minimum "level" a message must be in order to be logged by the channel. Monolog, which powers Hypervel's logging services, offers all of the log levels defined in the [RFC 5424 specification](https://tools.ietf.org/html/rfc5424). In descending order of severity, these log levels are: **emergency**, **alert**, **critical**, **error**, **warning**, **notice**, **info**, and **debug**.
-
-So, imagine we log a message using the `debug` method:
-
-```php
-Log::debug('An informational message.');
-```
-
-Given our configuration, the `syslog` channel will write the message to the system log; however, since the error message is not `critical` or above, it will not be sent to Slack. However, if we log an `emergency` message, it will be sent to both the system log and Slack since the `emergency` level is above our minimum level threshold for both channels:
-
-```php
-Log::emergency('The system is down!');
-```
-
-## Writing Log Messages
-
-You may write information to the logs using the `Log` [facade](/docs/facades). As previously mentioned, the logger provides the eight logging levels defined in the [RFC 5424 specification](https://tools.ietf.org/html/rfc5424): **emergency**, **alert**, **critical**, **error**, **warning**, **notice**, **info** and **debug**:
-
-```php
-use Hypervel\Support\Facades\Log;
-
-Log::emergency($message);
-Log::alert($message);
-Log::critical($message);
-Log::error($message);
-Log::warning($message);
-Log::notice($message);
-Log::info($message);
-Log::debug($message);
-```
-
-You may call any of these methods to log a message for the corresponding level. By default, the message will be written to the default log channel as configured by your `logging` configuration file:
-
-```php
- $id]);
-
- return view('user.profile', [
- 'user' => User::findOrFail($id)
- ]);
- }
-}
-```
-
-### Contextual Information
-
-An array of contextual data may be passed to the log methods. This contextual data will be formatted and displayed with the log message:
-
-```php
-use Hypervel\Support\Facades\Log;
-
-Log::info('User {id} failed to login.', ['id' => $user->id]);
-```
-
-Occasionally, you may wish to specify some contextual information that should be included with all subsequent log entries in a particular channel. For example, you may wish to log a request ID that is associated with each incoming request to your application. To accomplish this, you may call the `Log` facade's `withContext` method:
-
-```php
- $requestId
- ]);
-
- $response = $next($request);
-
- $response = $response->withHeader('Request-Id', $requestId);
-
- return $response;
- }
-}
-```
-
-If you would like to share contextual information across _all_ logging channels, you may invoke the `Log::shareContext()` method. This method will provide the contextual information to all created channels and any channels that are created subsequently:
-
-```php
- $requestId
- ]);
-
- // ...
- }
-}
-```
-
-::: note
-If you need to share log context while processing queued jobs, you may utilize [job middleware](/docs/queues#job-middleware).
-:::
-
-### Writing to Specific Channels
-
-Sometimes you may wish to log a message to a channel other than your application's default channel. You may use the `channel` method on the `Log` facade to retrieve and log to any channel defined in your configuration file:
-
-```php
-use Hypervel\Support\Facades\Log;
-
-Log::channel('slack')->info('Something happened!');
-```
-
-If you would like to create an on-demand logging stack consisting of multiple channels, you may use the `stack` method:
-
-```php
-Log::stack(['single', 'slack'])->info('Something happened!');
-```
-
-#### On-Demand Channels
-
-It is also possible to create an on-demand channel by providing the configuration at runtime without that configuration being present in your application's `logging` configuration file. To accomplish this, you may pass a configuration array to the `Log` facade's `build` method:
-
-```php
-use Hypervel\Support\Facades\Log;
-
-Log::build([
- 'driver' => 'single',
- 'path' => storage_path('logs/custom.log'),
-])->info('Something happened!');
-```
-
-You may also wish to include an on-demand channel in an on-demand logging stack. This can be achieved by including your on-demand channel instance in the array passed to the `stack` method:
-
-```php
-use Hypervel\Support\Facades\Log;
-
-$channel = Log::build([
- 'driver' => 'single',
- 'path' => storage_path('logs/custom.log'),
-]);
-
-Log::stack(['slack', $channel])->info('Something happened!');
-```
-
-## Monolog Channel Customization
-
-### Customizing Monolog for Channels
-
-Sometimes you may need complete control over how Monolog is configured for an existing channel. For example, you may want to configure a custom Monolog `FormatterInterface` implementation for Hypervel's built-in `single` channel.
-
-To get started, define a `tap` array on the channel's configuration. The `tap` array should contain a list of classes that should have an opportunity to customize (or "tap" into) the Monolog instance after it is created. There is no conventional location where these classes should be placed, so you are free to create a directory within your application to contain these classes:
-
-```php
-'single' => [
- 'driver' => 'single',
- 'tap' => [App\Logging\CustomizeFormatter::class],
- 'path' => storage_path('logs/hypervel.log'),
- 'level' => 'debug',
-],
-```
-
-Once you have configured the `tap` option on your channel, you're ready to define the class that will customize your Monolog instance. This class only needs a single method: `__invoke`, which receives an `Hypervel\Log\Logger` instance. The `Hypervel\Log\Logger` instance proxies all method calls to the underlying Monolog instance:
-
-```php
-getHandlers() as $handler) {
- $handler->setFormatter(new LineFormatter(
- '[%datetime%] %channel%.%level_name%: %message% %context% %extra%'
- ));
- }
- }
-}
-```
-
-::: note
-All of your "tap" classes are resolved by the [service container](/docs/container), so any constructor dependencies they require will automatically be injected.
-:::
-
-### Creating Monolog Handler Channels
-
-Monolog has a variety of [available handlers](https://github.com/Seldaek/monolog/tree/main/src/Monolog/Handler) and Hypervel does not include a built-in channel for each one. In some cases, you may wish to create a custom channel that is merely an instance of a specific Monolog handler that does not have a corresponding Hypervel log driver. These channels can be easily created using the `monolog` driver.
-
-When using the `monolog` driver, the `handler` configuration option is used to specify which handler will be instantiated. Optionally, any constructor parameters the handler needs may be specified using the `with` configuration option:
-
-```php
-'logentries' => [
- 'driver' => 'monolog',
- 'handler' => Monolog\Handler\SyslogUdpHandler::class,
- 'with' => [
- 'host' => 'my.logentries.internal.datahubhost.company.com',
- 'port' => '10000',
- ],
-],
-```
-
-#### Monolog Formatters
-
-When using the `monolog` driver, the Monolog `LineFormatter` will be used as the default formatter. However, you may customize the type of formatter passed to the handler using the `formatter` and `formatter_with` configuration options:
-
-```php
-'browser' => [
- 'driver' => 'monolog',
- 'handler' => Monolog\Handler\BrowserConsoleHandler::class,
- 'formatter' => Monolog\Formatter\HtmlFormatter::class,
- 'formatter_with' => [
- 'dateFormat' => 'Y-m-d',
- ],
-],
-```
-
-If you are using a Monolog handler that is capable of providing its own formatter, you may set the value of the `formatter` configuration option to `default`:
-
-```php
-'newrelic' => [
- 'driver' => 'monolog',
- 'handler' => Monolog\Handler\NewRelicHandler::class,
- 'formatter' => 'default',
-],
-```
-
- #### Monolog Processors
-
- Monolog can also process messages before logging them. You can create your own processors or use the [existing processors offered by Monolog](https://github.com/Seldaek/monolog/tree/main/src/Monolog/Processor).
-
- If you would like to customize the processors for a `monolog` driver, add a `processors` configuration value to your channel's configuration:
-
-```php
-'memory' => [
- 'driver' => 'monolog',
- 'handler' => Monolog\Handler\StreamHandler::class,
- 'with' => [
- 'stream' => 'php://stderr',
- ],
- 'processors' => [
- // Simple syntax...
- Monolog\Processor\MemoryUsageProcessor::class,
-
- // With options...
- [
- 'processor' => Monolog\Processor\PsrLogMessageProcessor::class,
- 'with' => ['removeUsedContextFields' => true],
- ],
- ],
-],
-```
-
-### Creating Custom Channels via Factories
-
-If you would like to define an entirely custom channel in which you have full control over Monolog's instantiation and configuration, you may specify a `custom` driver type in your `config/logging.php` configuration file. Your configuration should include a `via` option that contains the name of the factory class which will be invoked to create the Monolog instance:
-
-```php
-'channels' => [
- 'example-custom-channel' => [
- 'driver' => 'custom',
- 'via' => App\Logging\CreateCustomLogger::class,
- ],
-],
-```
-
-Once you have configured the `custom` driver channel, you're ready to define the class that will create your Monolog instance. This class only needs a single `__invoke` method which should return the Monolog logger instance. The method will receive the channels configuration array as its only argument:
-
-```php
- env('MAIL_MAILER', 'mailgun'),
-```
-
-Second, add the following configuration array to your array of `mailers`:
-
-```php
-'mailgun' => [
- 'transport' => 'mailgun',
- // 'client' => [
- // 'timeout' => 5,
- // ],
-],
-```
-
-After configuring your application's default mailer, add the following options to your `config/services.php` configuration file:
-
-```php
-'mailgun' => [
- 'domain' => env('MAILGUN_DOMAIN'),
- 'secret' => env('MAILGUN_SECRET'),
- 'endpoint' => env('MAILGUN_ENDPOINT', 'api.mailgun.net'),
- 'scheme' => 'https',
-],
-```
-
-If you are not using the United States [Mailgun region](https://documentation.mailgun.com/en/latest/api-intro.html#mailgun-regions), you may define your region's endpoint in the `services` configuration file:
-
-```php
-'mailgun' => [
- 'domain' => env('MAILGUN_DOMAIN'),
- 'secret' => env('MAILGUN_SECRET'),
- 'endpoint' => env('MAILGUN_ENDPOINT', 'api.eu.mailgun.net'),
- 'scheme' => 'https',
-],
-```
-
-#### Postmark Driver
-
-To use the [Postmark](https://postmarkapp.com/) driver, install Symfony's Postmark Mailer transport via Composer:
-
-```shell:no-line-numbers
-composer require symfony/postmark-mailer symfony/http-client
-```
-
-Next, set the `default` option in your application's `config/mail.php` configuration file to `postmark`. After configuring your application's default mailer, ensure that your `config/services.php` configuration file contains the following options:
-
-```php
-'postmark' => [
- 'token' => env('POSTMARK_TOKEN'),
-],
-```
-
-If you would like to specify the Postmark message stream that should be used by a given mailer, you may add the `message_stream_id` configuration option to the mailer's configuration array. This configuration array can be found in your application's `config/mail.php` configuration file:
-
-```php
-'postmark' => [
- 'transport' => 'postmark',
- 'message_stream_id' => env('POSTMARK_MESSAGE_STREAM_ID'),
- // 'client' => [
- // 'timeout' => 5,
- // ],
-],
-```
-
-This way you are also able to set up multiple Postmark mailers with different message streams.
-
-#### Resend Driver
-
-To use the [Resend](https://resend.com/) driver, install Resend's PHP SDK via Composer:
-
-```shell:no-line-numbers
-composer require resend/resend-php
-```
-
-Next, set the `default` option in your application's `config/mail.php` configuration file to `resend`. After configuring your application's default mailer, ensure that your `config/services.php` configuration file contains the following options:
-
-```php
-'resend' => [
- 'key' => env('RESEND_KEY'),
-],
-```
-
-#### SES Driver
-
-To use the Amazon SES driver you must first install the Amazon AWS SDK for PHP. You may install this library via the Composer package manager:
-
-```shell:no-line-numbers
-composer require aws/aws-sdk-php
-```
-
-Next, set the `default` option in your `config/mail.php` configuration file to `ses` and verify that your `config/services.php` configuration file contains the following options:
-
-```php
-'ses' => [
- 'key' => env('AWS_ACCESS_KEY_ID'),
- 'secret' => env('AWS_SECRET_ACCESS_KEY'),
- 'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
-],
-```
-
-To utilize AWS [temporary credentials](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) via a session token, you may add a `token` key to your application's SES configuration:
-
-```php
-'ses' => [
- 'key' => env('AWS_ACCESS_KEY_ID'),
- 'secret' => env('AWS_SECRET_ACCESS_KEY'),
- 'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
- 'token' => env('AWS_SESSION_TOKEN'),
-],
-```
-
-To interact with SES's [subscription management features](https://docs.aws.amazon.com/ses/latest/dg/sending-email-subscription-management.html), you may return the `X-Ses-List-Management-Options` header in the array returned by the [`headers`](#headers) method of a mail message:
-
-```php
-/**
- * Get the message headers.
- */
-public function headers(): Headers
-{
- return new Headers(
- text: [
- 'X-Ses-List-Management-Options' => 'contactListName=MyContactList;topicName=MyTopic',
- ],
- );
-}
-```
-
-If you would like to define [additional options](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sesv2-2019-09-27.html#sendemail) that Hypervel should pass to the AWS SDK's `SendEmail` method when sending an email, you may define an `options` array within your `ses` configuration:
-
-```php
-'ses' => [
- 'key' => env('AWS_ACCESS_KEY_ID'),
- 'secret' => env('AWS_SECRET_ACCESS_KEY'),
- 'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
- 'options' => [
- 'ConfigurationSetName' => 'MyConfigurationSet',
- 'EmailTags' => [
- ['Name' => 'foo', 'Value' => 'bar'],
- ],
- ],
-],
-```
-
-#### MailerSend Driver
-
-[MailerSend](https://www.mailersend.com/), a transactional email and SMS service, maintains their own API based mail driver for Hypervel. The package containing the driver may be installed via the Composer package manager:
-
-```shell:no-line-numbers
-composer require mailersend/laravel-driver
-```
-
-Once the package is installed, add the `MAILERSEND_API_KEY` environment variable to your application's `.env` file. In addition, the `MAIL_MAILER` environment variable should be defined as `mailersend`:
-
-```ini
-MAIL_MAILER=mailersend
-MAIL_FROM_ADDRESS=app@yourdomain.com
-MAIL_FROM_NAME="App Name"
-
-MAILERSEND_API_KEY=your-api-key
-```
-
-Finally, add MailerSend to the `mailers` array in your application's `config/mail.php` configuration file:
-
-```php
-'mailersend' => [
- 'transport' => 'mailersend',
-],
-```
-
-To learn more about MailerSend, including how to use hosted templates, consult the [MailerSend driver documentation](https://github.com/mailersend/mailersend-laravel-driver#usage).
-
-### Failover Configuration
-
-Sometimes, an external service you have configured to send your application's mail may be down. In these cases, it can be useful to define one or more backup mail delivery configurations that will be used in case your primary delivery driver is down.
-
-To accomplish this, you should define a mailer within your application's `mail` configuration file that uses the `failover` transport. The configuration array for your application's `failover` mailer should contain an array of `mailers` that reference the order in which configured mailers should be chosen for delivery:
-
-```php
-'mailers' => [
- 'failover' => [
- 'transport' => 'failover',
- 'mailers' => [
- 'postmark',
- 'mailgun',
- 'sendmail',
- ],
- ],
-
- // ...
-],
-```
-
-Once your failover mailer has been defined, you should set this mailer as the default mailer used by your application by specifying its name as the value of the `default` configuration key within your application's `mail` configuration file:
-
-```php
-'default' => env('MAIL_MAILER', 'failover'),
-```
-
-### Round Robin Configuration
-
-The `roundrobin` transport allows you to distribute your mailing workload across multiple mailers. To get started, define a mailer within your application's `mail` configuration file that uses the `roundrobin` transport. The configuration array for your application's `roundrobin` mailer should contain an array of `mailers` that reference which configured mailers should be used for delivery:
-
-```php
-'mailers' => [
- 'roundrobin' => [
- 'transport' => 'roundrobin',
- 'mailers' => [
- 'ses',
- 'postmark',
- ],
- ],
-
- // ...
-],
-```
-
-Once your round robin mailer has been defined, you should set this mailer as the default mailer used by your application by specifying its name as the value of the `default` configuration key within your application's `mail` configuration file:
-
-```php
-'default' => env('MAIL_MAILER', 'roundrobin'),
-```
-
-The round robin transport selects a random mailer from the list of configured mailers and then switches to the next available mailer for each subsequent email. In contrast to `failover` transport, which helps to achieve *[high availability](https://en.wikipedia.org/wiki/High_availability)*, the `roundrobin` transport provides *[load balancing](https://en.wikipedia.org/wiki/Load_balancing_(computing))*.
-
-## Generating Mailables
-
-When building Hypervel applications, each type of email sent by your application is represented as a "mailable" class. These classes are stored in the `app/Mail` directory. Don't worry if you don't see this directory in your application, since it will be generated for you when you create your first mailable class using the `make:mail` Artisan command:
-
-```shell:no-line-numbers
-php artisan make:mail OrderShipped
-```
-
-## Writing Mailables
-
-Once you have generated a mailable class, open it up so we can explore its contents. Mailable class configuration is done in several methods, including the `envelope`, `content`, and `attachments` methods.
-
-The `envelope` method returns an `Hypervel\Mail\Mailables\Envelope` object that defines the subject and, sometimes, the recipients of the message. The `content` method returns an `Hypervel\Mail\Mailables\Content` object that defines the [Blade template](/docs/blade) that will be used to generate the message content.
-
-### Configuring the Sender
-
-#### Using the Envelope
-
-First, let's explore configuring the sender of the email. Or, in other words, who the email is going to be "from". There are two ways to configure the sender. First, you may specify the "from" address on your message's envelope:
-
-```php
-use Hypervel\Mail\Mailables\Address;
-use Hypervel\Mail\Mailables\Envelope;
-
-/**
- * Get the message envelope.
- */
-public function envelope(): Envelope
-{
- return new Envelope(
- from: new Address('jeffrey@example.com', 'Jeffrey Way'),
- subject: 'Order Shipped',
- );
-}
-```
-
-If you would like, you may also specify a `replyTo` address:
-
-```php
-return new Envelope(
- from: new Address('jeffrey@example.com', 'Jeffrey Way'),
- replyTo: [
- new Address('taylor@example.com', 'Taylor Otwell'),
- ],
- subject: 'Order Shipped',
-);
-```
-
-#### Using a Global `from` Address
-
-However, if your application uses the same "from" address for all of its emails, it can become cumbersome to add it to each mailable class you generate. Instead, you may specify a global "from" address in your `config/mail.php` configuration file. This address will be used if no other "from" address is specified within the mailable class:
-
-```php
-'from' => [
- 'address' => env('MAIL_FROM_ADDRESS', 'hello@example.com'),
- 'name' => env('MAIL_FROM_NAME', 'Example'),
-],
-```
-
-In addition, you may define a global "reply_to" address within your `config/mail.php` configuration file:
-
-```php
-'reply_to' => ['address' => 'example@example.com', 'name' => 'App Name'],
-```
-
-### Configuring the View
-
-Within a mailable class's `content` method, you may define the `view`, or which template should be used when rendering the email's contents. Since each email typically uses a [Blade template](/docs/blade) to render its contents, you have the full power and convenience of the Blade templating engine when building your email's HTML:
-
-```php
-/**
- * Get the message content definition.
- */
-public function content(): Content
-{
- return new Content(
- view: 'mail.orders.shipped',
- );
-}
-```
-
-::: note
-You may wish to create a `resources/views/emails` directory to house all of your email templates; however, you are free to place them wherever you wish within your `resources/views` directory.
-:::
-
-#### Plain Text Emails
-
-If you would like to define a plain-text version of your email, you may specify the plain-text template when creating the message's `Content` definition. Like the `view` parameter, the `text` parameter should be a template name which will be used to render the contents of the email. You are free to define both an HTML and plain-text version of your message:
-
-```php
-/**
- * Get the message content definition.
- */
-public function content(): Content
-{
- return new Content(
- view: 'mail.orders.shipped',
- text: 'mail.orders.shipped-text'
- );
-}
-```
-
-For clarity, the `html` parameter may be used as an alias of the `view` parameter:
-
-```php
-return new Content(
- html: 'mail.orders.shipped',
- text: 'mail.orders.shipped-text'
-);
-```
-
-### View Data
-
-#### Via Public Properties
-
-Typically, you will want to pass some data to your view that you can utilize when rendering the email's HTML. There are two ways you may make data available to your view. First, any public property defined on your mailable class will automatically be made available to the view. So, for example, you may pass data into your mailable class's constructor and set that data to public properties defined on the class:
-
-```php
-
- Price: {{ $order->price }}
-
-```
-
-#### Via the `with` Parameter:
-
-If you would like to customize the format of your email's data before it is sent to the template, you may manually pass your data to the view via the `Content` definition's `with` parameter. Typically, you will still pass data via the mailable class's constructor; however, you should set this data to `protected` or `private` properties so the data is not automatically made available to the template:
-
-```php
- $this->order->name,
- 'orderPrice' => $this->order->price,
- ],
- );
- }
-}
-```
-
-Once the data has been passed to the `with` method, it will automatically be available in your view, so you may access it like you would access any other data in your Blade templates:
-
-```html
-
- Price: {{ $orderPrice }}
-
-```
-
-### Attachments
-
-To add attachments to an email, you will add attachments to the array returned by the message's `attachments` method. First, you may add an attachment by providing a file path to the `fromPath` method provided by the `Attachment` class:
-
-```php
-use Hypervel\Mail\Mailables\Attachment;
-
-/**
- * Get the attachments for the message.
- *
- * @return array }})
-
-```
-
-### Attachable Objects
-
-While attaching files to messages via simple string paths is often sufficient, in many cases the attachable entities within your application are represented by classes. For example, if your application is attaching a photo to a message, your application may also have a `Photo` model that represents that photo. When that is the case, wouldn't it be convenient to simply pass the `Photo` model to the `attach` method? Attachable objects allow you to do just that.
-
-To get started, implement the `Hypervel\Mail\Contracts\Attachable` interface on the object that will be attachable to messages. This interface dictates that your class defines a `toMailAttachment` method that returns an `Hypervel\Mail\Attachment` instance:
-
-```php
-
- */
-public function attachments(): array
-{
- return [$this->photo];
-}
-```
-
-Of course, attachment data may be stored on a remote file storage service such as Amazon S3. So, Hypervel also allows you to generate attachment instances from data that is stored on one of your application's [filesystem disks](/docs/filesystem):
-
-```php
-// Create an attachment from a file on your default disk...
-return Attachment::fromStorage($this->path);
-
-// Create an attachment from a file on a specific disk...
-return Attachment::fromStorageDisk('backblaze', $this->path);
-```
-
-In addition, you may create attachment instances via data that you have in memory. To accomplish this, provide a closure to the `fromData` method. The closure should return the raw data that represents the attachment:
-
-```php
-return Attachment::fromData(fn () => $this->content, 'Photo Name');
-```
-
-Hypervel also provides additional methods that you may use to customize your attachments. For example, you may use the `as` and `withMime` methods to customize the file's name and MIME type:
-
-```php
-return Attachment::fromPath('/path/to/file')
- ->as('Photo Name')
- ->withMime('image/jpeg');
-```
-
-### Headers
-
-Sometimes you may need to attach additional headers to the outgoing message. For instance, you may need to set a custom `Message-Id` or other arbitrary text headers.
-
-To accomplish this, define a `headers` method on your mailable. The `headers` method should return an `Hypervel\Mail\Mailables\Headers` instance. This class accepts `messageId`, `references`, and `text` parameters. Of course, you may provide only the parameters you need for your particular message:
-
-```php
-use Hypervel\Mail\Mailables\Headers;
-
-/**
- * Get the message headers.
- */
-public function headers(): Headers
-{
- return new Headers(
- messageId: 'custom-message-id@example.com',
- references: ['previous-message@example.com'],
- text: [
- 'X-Custom-Header' => 'Custom Value',
- ],
- );
-}
-```
-
-### Tags and Metadata
-
-Some third-party email providers such as Mailgun and Postmark support message "tags" and "metadata", which may be used to group and track emails sent by your application. You may add tags and metadata to an email message via your `Envelope` definition:
-
-```php
-use Hypervel\Mail\Mailables\Envelope;
-
-/**
- * Get the message envelope.
- *
- * @return \Hypervel\Mail\Mailables\Envelope
- */
-public function envelope(): Envelope
-{
- return new Envelope(
- subject: 'Order Shipped',
- tags: ['shipment'],
- metadata: [
- 'order_id' => $this->order->id,
- ],
- );
-}
-```
-
-If your application is using the Mailgun driver, you may consult Mailgun's documentation for more information on [tags](https://documentation.mailgun.com/docs/mailgun/user-manual/tracking-messages/#tagging) and [metadata](https://documentation.mailgun.com/docs/mailgun/user-manual/tracking-messages/#attaching-data-to-messages). Likewise, the Postmark documentation may also be consulted for more information on their support for [tags](https://postmarkapp.com/blog/tags-support-for-smtp) and [metadata](https://postmarkapp.com/support/article/1125-custom-metadata-faq).
-
-If your application is using Amazon SES to send emails, you should use the `metadata` method to attach [SES "tags"](https://docs.aws.amazon.com/ses/latest/APIReference/API_MessageTag.html) to the message.
-
-### Customizing the Symfony Message
-
-Hypervel's mail capabilities are powered by Symfony Mailer. Hypervel allows you to register custom callbacks that will be invoked with the Symfony Message instance before sending the message. This gives you an opportunity to deeply customize the message before it is sent. To accomplish this, define a `using` parameter on your `Envelope` definition:
-
-```php
-use Hypervel\Mail\Mailables\Envelope;
-use Symfony\Component\Mime\Email;
-
-/**
- * Get the message envelope.
- */
-public function envelope(): Envelope
-{
- return new Envelope(
- subject: 'Order Shipped',
- using: [
- function (Email $message) {
- // ...
- },
- ]
- );
-}
-```
-
-## Markdown Mailables
-
-Markdown mailable messages allow you to take advantage of the pre-built templates and components of [mail notifications](/docs/notifications#mail-notifications) in your mailables. Since the messages are written in Markdown, Hypervel is able to render beautiful, responsive HTML templates for the messages while also automatically generating a plain-text counterpart.
-
-### Generating Markdown Mailables
-
-To generate a mailable with a corresponding Markdown template, you may use the `--markdown` option of the `make:mail` Artisan command:
-
-```shell:no-line-numbers
-php artisan make:mail OrderShipped --markdown=mail.orders.shipped
-```
-
-When configuring the mailable `Content` definition within its `content` method, use the `markdown` parameter instead of the `view` parameter:
-
-```php
-use Hypervel\Mail\Mailables\Content;
-
-/**
- * Get the message content definition.
- */
-public function content(): Content
-{
- return new Content(
- markdown: 'mail.orders.shipped',
- with: [
- 'url' => $this->orderUrl,
- ],
- );
-}
-```
-
-> `make:mail` is not supported yet.
-
-### Writing Markdown Messages
-
-Markdown mailables use a combination of Blade components and Markdown syntax which allow you to easily construct mail messages while leveraging Hypervel's pre-built email UI components:
-
-```html
--{{ config('app.name') }} -
-
-[boolean](#column-method-boolean)
-
-
-
-#### String & Text Types
-
-
-
-[char](#column-method-char)
-[longText](#column-method-longText)
-[mediumText](#column-method-mediumText)
-[string](#column-method-string)
-[text](#column-method-text)
-[tinyText](#column-method-tinyText)
-
-
-
-#### Numeric Types
-
-
-
-[bigIncrements](#column-method-bigIncrements)
-[bigInteger](#column-method-bigInteger)
-[decimal](#column-method-decimal)
-[double](#column-method-double)
-[float](#column-method-float)
-[id](#column-method-id)
-[increments](#column-method-increments)
-[integer](#column-method-integer)
-[mediumIncrements](#column-method-mediumIncrements)
-[mediumInteger](#column-method-mediumInteger)
-[smallIncrements](#column-method-smallIncrements)
-[smallInteger](#column-method-smallInteger)
-[tinyIncrements](#column-method-tinyIncrements)
-[tinyInteger](#column-method-tinyInteger)
-[unsignedBigInteger](#column-method-unsignedBigInteger)
-[unsignedInteger](#column-method-unsignedInteger)
-[unsignedMediumInteger](#column-method-unsignedMediumInteger)
-[unsignedSmallInteger](#column-method-unsignedSmallInteger)
-[unsignedTinyInteger](#column-method-unsignedTinyInteger)
-
-
-
-#### Date & Time Types
-
-
-
-[dateTime](#column-method-dateTime)
-[dateTimeTz](#column-method-dateTimeTz)
-[date](#column-method-date)
-[time](#column-method-time)
-[timeTz](#column-method-timeTz)
-[timestamp](#column-method-timestamp)
-[timestamps](#column-method-timestamps)
-[timestampsTz](#column-method-timestampsTz)
-[softDeletes](#column-method-softDeletes)
-[softDeletesTz](#column-method-softDeletesTz)
-[year](#column-method-year)
-
-
-
-#### Binary Types
-
-
-
-[binary](#column-method-binary)
-
-
-
-#### Object & Json Types
-
-
-
-[json](#column-method-json)
-[jsonb](#column-method-jsonb)
-
-
-
-#### UUID
-
-
-
-[uuid](#column-method-uuid)
-[uuidMorphs](#column-method-uuidMorphs)
-
-
-
-#### Spatial Types
-
-
-
-[geometry](#column-method-geometry)
-
-
-
-#### Relationship Types
-
-
-
-[foreignId](#column-method-foreignId)
-[foreignUlid](#column-method-foreignUlid)
-[foreignUuid](#column-method-foreignUuid)
-[morphs](#column-method-morphs)
-[nullableMorphs](#column-method-nullableMorphs)
-
-
-
-#### Specialty Types
-
-
-
-[enum](#column-method-enum)
-[set](#column-method-set)
-[macAddress](#column-method-macAddress)
-[ipAddress](#column-method-ipAddress)
-[rememberToken](#column-method-rememberToken)
-[vector](#column-method-vector)
-
-
-
-
-#### bigIncrements()
-
-The `bigIncrements` method creates an auto-incrementing `UNSIGNED BIGINT` (primary key) equivalent column:
-
-```php
-$table->bigIncrements('id');
-```
-
-
-#### bigInteger()
-
-The `bigInteger` method creates a `BIGINT` equivalent column:
-
-```php
-$table->bigInteger('votes');
-```
-
-
-#### binary()
-
-The `binary` method creates a `BLOB` equivalent column:
-
-```php
-$table->binary('photo');
-```
-
-When utilizing MySQL, MariaDB, or SQL Server, you may pass `length` and `fixed` arguments to create `VARBINARY` or `BINARY` equivalent column:
-
-```php
-$table->binary('data', length: 16); // VARBINARY(16)
-
-$table->binary('data', length: 16, fixed: true); // BINARY(16)
-```
-
-
-#### boolean()
-
-The `boolean` method creates a `BOOLEAN` equivalent column:
-
-```php
-$table->boolean('confirmed');
-```
-
-
-#### char()
-
-The `char` method creates a `CHAR` equivalent column with of a given length:
-
-```php
-$table->char('name', length: 100);
-```
-
-
-#### dateTimeTz()
-
-The `dateTimeTz` method creates a `DATETIME` (with timezone) equivalent column with an optional fractional seconds precision:
-
-```php
-$table->dateTimeTz('created_at', precision: 0);
-```
-
-
-#### dateTime()
-
-The `dateTime` method creates a `DATETIME` equivalent column with an optional fractional seconds precision:
-
-```php
-$table->dateTime('created_at', precision: 0);
-```
-
-
-#### date()
-
-The `date` method creates a `DATE` equivalent column:
-
-```php
-$table->date('created_at');
-```
-
-
-#### decimal()
-
-The `decimal` method creates a `DECIMAL` equivalent column with the given precision (total digits) and scale (decimal digits):
-
-```php
-$table->decimal('amount', total: 8, places: 2);
-```
-
-
-#### double()
-
-The `double` method creates a `DOUBLE` equivalent column:
-
-```php
-$table->double('amount');
-```
-
-
-#### enum()
-
-The `enum` method creates a `ENUM` equivalent column with the given valid values:
-
-```php
-$table->enum('difficulty', ['easy', 'hard']);
-```
-
-
-#### float()
-
-The `float` method creates a `FLOAT` equivalent column with the given precision:
-
-```php
-$table->float('amount', precision: 53);
-```
-
-
-#### foreignId()
-
-The `foreignId` method creates an `UNSIGNED BIGINT` equivalent column:
-
-```php
-$table->foreignId('user_id');
-```
-
-
-#### foreignUlid()
-
-The `foreignUlid` method creates a `ULID` equivalent column:
-
-```php
-$table->foreignUlid('user_id');
-```
-
-
-#### foreignUuid()
-
-The `foreignUuid` method creates a `UUID` equivalent column:
-
-```php
-$table->foreignUuid('user_id');
-```
-
-
-#### geometry()
-
-The `geometry` method creates a `GEOMETRY` equivalent column with the given spatial type and SRID (Spatial Reference System Identifier):
-
-```php
-$table->geometry('positions', subtype: 'point', srid: 0);
-```
-
-::: note
-Support for spatial types depends on your database driver. Please refer to your database's documentation. If your application is utilizing a PostgreSQL database, you must install the [PostGIS](https://postgis.net) extension before the `geometry` method may be used.
-:::
-
-
-#### id()
-
-The `id` method is an alias of the `bigIncrements` method. By default, the method will create an `id` column; however, you may pass a column name if you would like to assign a different name to the column:
-
-```php
-$table->id();
-```
-
-
-#### increments()
-
-The `increments` method creates an auto-incrementing `UNSIGNED INTEGER` equivalent column as a primary key:
-
-```php
-$table->increments('id');
-```
-
-
-#### integer()
-
-The `integer` method creates an `INTEGER` equivalent column:
-
-```php
-$table->integer('votes');
-```
-
-
-#### ipAddress()
-
-The `ipAddress` method creates a `VARCHAR` equivalent column:
-
-```php
-$table->ipAddress('visitor');
-```
-
-When using PostgreSQL, an `INET` column will be created.
-
-
-#### json()
-
-The `json` method creates a `JSON` equivalent column:
-
-```php
-$table->json('options');
-```
-
-When using SQLite, a `TEXT` column will be created.
-
-
-#### jsonb()
-
-The `jsonb` method creates a `JSONB` equivalent column:
-
-```php
-$table->jsonb('options');
-```
-
-When using SQLite, a `TEXT` column will be created.
-
-
-#### longText()
-
-The `longText` method creates a `LONGTEXT` equivalent column:
-
-```php
-$table->longText('description');
-```
-
-When utilizing MySQL or MariaDB, you may apply a `binary` character set to the column in order to create a `LONGBLOB` equivalent column:
-
-```php
-$table->longText('data')->charset('binary'); // LONGBLOB
-```
-
-
-#### macAddress()
-
-The `macAddress` method creates a column that is intended to hold a MAC address. Some database systems, such as PostgreSQL, have a dedicated column type for this type of data. Other database systems will use a string equivalent column:
-
-```php
-$table->macAddress('device');
-```
-
-
-#### mediumIncrements()
-
-The `mediumIncrements` method creates an auto-incrementing `UNSIGNED MEDIUMINT` equivalent column as a primary key:
-
-```php
-$table->mediumIncrements('id');
-```
-
-
-#### mediumInteger()
-
-The `mediumInteger` method creates a `MEDIUMINT` equivalent column:
-
-```php
-$table->mediumInteger('votes');
-```
-
-
-#### mediumText()
-
-The `mediumText` method creates a `MEDIUMTEXT` equivalent column:
-
-```php
-$table->mediumText('description');
-```
-
-When utilizing MySQL or MariaDB, you may apply a `binary` character set to the column in order to create a `MEDIUMBLOB` equivalent column:
-
-```php
-$table->mediumText('data')->charset('binary'); // MEDIUMBLOB
-```
-
-
-#### morphs()
-
-The `morphs` method is a convenience method that adds a `{column}_id` equivalent column and a `{column}_type` `VARCHAR` equivalent column. The column type for the `{column}_id` will be `UNSIGNED BIGINT`, `CHAR(36)`, or `CHAR(26)` depending on the model key type.
-
-This method is intended to be used when defining the columns necessary for a polymorphic [Eloquent relationship](/docs/eloquent-relationships). In the following example, `taggable_id` and `taggable_type` columns would be created:
-
-```php
-$table->morphs('taggable');
-```
-
-
-#### nullableMorphs()
-
-The method is similar to the [morphs](#column-method-morphs) method; however, the columns that are created will be "nullable":
-
-```php
-$table->nullableMorphs('taggable');
-```
-
-
-#### rememberToken()
-
-The `rememberToken` method creates a nullable, `VARCHAR(100)` equivalent column that is intended to store the current "remember me" [authentication token](/docs/authentication#remembering-users):
-
-```php
-$table->rememberToken();
-```
-
-
-#### set()
-
-The `set` method creates a `SET` equivalent column with the given list of valid values:
-
-```php
-$table->set('flavors', ['strawberry', 'vanilla']);
-```
-
-
-#### smallIncrements()
-
-The `smallIncrements` method creates an auto-incrementing `UNSIGNED SMALLINT` equivalent column as a primary key:
-
-```php
-$table->smallIncrements('id');
-```
-
-
-#### smallInteger()
-
-The `smallInteger` method creates a `SMALLINT` equivalent column:
-
-```php
-$table->smallInteger('votes');
-```
-
-
-#### softDeletesTz()
-
-The `softDeletesTz` method adds a nullable `deleted_at` `TIMESTAMP` (with timezone) equivalent column with an optional fractional seconds precision. This column is intended to store the `deleted_at` timestamp needed for Eloquent's "soft delete" functionality:
-
-```php
-$table->softDeletesTz('deleted_at', precision: 0);
-```
-
-
-#### softDeletes()
-
-The `softDeletes` method adds a nullable `deleted_at` `TIMESTAMP` equivalent column with an optional fractional seconds precision. This column is intended to store the `deleted_at` timestamp needed for Eloquent's "soft delete" functionality:
-
-```php
-$table->softDeletes('deleted_at', precision: 0);
-```
-
-
-#### string()
-
-The `string` method creates a `VARCHAR` equivalent column of the given length:
-
-```php
-$table->string('name', length: 100);
-```
-
-
-#### text()
-
-The `text` method creates a `TEXT` equivalent column:
-
-```php
-$table->text('description');
-```
-
-When utilizing MySQL or MariaDB, you may apply a `binary` character set to the column in order to create a `BLOB` equivalent column:
-
-```php
-$table->text('data')->charset('binary'); // BLOB
-```
-
-
-#### timeTz()
-
-The `timeTz` method creates a `TIME` (with timezone) equivalent column with an optional fractional seconds precision:
-
-```php
-$table->timeTz('sunrise', precision: 0);
-```
-
-
-#### time()
-
-The `time` method creates a `TIME` equivalent column with an optional fractional seconds precision:
-
-```php
-$table->time('sunrise', precision: 0);
-```
-
-
-#### timestampTz()
-
-The `timestampTz` method creates a `TIMESTAMP` (with timezone) equivalent column with an optional fractional seconds precision:
-
-```php
-$table->timestampTz('added_at', precision: 0);
-```
-
-
-#### timestamp()
-
-The `timestamp` method creates a `TIMESTAMP` equivalent column with an optional fractional seconds precision:
-
-```php
-$table->timestamp('added_at', precision: 0);
-```
-
-
-#### timestampsTz()
-
-The `timestampsTz` method creates `created_at` and `updated_at` `TIMESTAMP` (with timezone) equivalent columns with an optional fractional seconds precision:
-
-```php
-$table->timestampsTz(precision: 0);
-```
-
-
-#### timestamps()
-
-The `timestamps` method creates `created_at` and `updated_at` `TIMESTAMP` equivalent columns with an optional fractional seconds precision:
-
-```php
-$table->timestamps(precision: 0);
-```
-
-
-#### tinyIncrements()
-
-The `tinyIncrements` method creates an auto-incrementing `UNSIGNED TINYINT` equivalent column as a primary key:
-
-```php
-$table->tinyIncrements('id');
-```
-
-
-#### tinyInteger()
-
-The `tinyInteger` method creates a `TINYINT` equivalent column:
-
-```php
-$table->tinyInteger('votes');
-```
-
-
-#### tinyText()
-
-The `tinyText` method creates a `TINYTEXT` equivalent column:
-
-```php
-$table->tinyText('notes');
-```
-
-When utilizing MySQL or MariaDB, you may apply a `binary` character set to the column in order to create a `TINYBLOB` equivalent column:
-
-```php
-$table->tinyText('data')->charset('binary'); // TINYBLOB
-```
-
-
-#### unsignedBigInteger()
-
-The `unsignedBigInteger` method creates an `UNSIGNED BIGINT` equivalent column:
-
-```php
-$table->unsignedBigInteger('votes');
-```
-
-
-#### unsignedInteger()
-
-The `unsignedInteger` method creates an `UNSIGNED INTEGER` equivalent column:
-
-```php
-$table->unsignedInteger('votes');
-```
-
-
-#### unsignedMediumInteger()
-
-The `unsignedMediumInteger` method creates an `UNSIGNED MEDIUMINT` equivalent column:
-
-```php
-$table->unsignedMediumInteger('votes');
-```
-
-
-#### unsignedSmallInteger()
-
-The `unsignedSmallInteger` method creates an `UNSIGNED SMALLINT` equivalent column:
-
-```php
-$table->unsignedSmallInteger('votes');
-```
-
-
-#### unsignedTinyInteger()
-
-The `unsignedTinyInteger` method creates an `UNSIGNED TINYINT` equivalent column:
-
-```php
-$table->unsignedTinyInteger('votes');
-```
-
-
-#### uuidMorphs()
-
-The `uuidMorphs` method is a convenience method that adds a `{column}_id` `CHAR(36)` equivalent column and a `{column}_type` `VARCHAR` equivalent column.
-
-This method is intended to be used when defining the columns necessary for a polymorphic [Eloquent relationship](/docs/eloquent-relationships) that use UUID identifiers. In the following example, `taggable_id` and `taggable_type` columns would be created:
-
-```php
-$table->uuidMorphs('taggable');
-```
-
-
-#### ulid()
-
-The `ulid` method creates a `ULID` equivalent column:
-
-```php
-$table->ulid('id');
-```
-
-
-#### uuid()
-
-The `uuid` method creates a `UUID` equivalent column:
-
-```php
-$table->uuid('id');
-```
-
-
-#### vector()
-
-The `vector` method creates a `vector` equivalent column:
-
-```php
-$table->vector('embedding', dimensions: 100);
-```
-
-
-#### year()
-
-The `year` method creates a `YEAR` equivalent column:
-
-```php
-$table->year('birth_year');
-```
-
-### Column Modifiers
-
-In addition to the column types listed above, there are several column "modifiers" you may use when adding a column to a database table. For example, to make the column "nullable", you may use the `nullable` method:
-
-```php
-use Hyperf\Database\Schema\Blueprint;
-use Hypervel\Support\Facades\Schema;
-
-Schema::table('users', function (Blueprint $table) {
- $table->string('email')->nullable();
-});
-```
-
-The following table contains all of the available column modifiers. This list does not include [index modifiers](#creating-indexes):
-
-
-
-| Modifier | Description |
-| ----------------------------------- | ---------------------------------------------------------------------------------------------- |
-| `->after('column')` | Place the column "after" another column (MariaDB / MySQL). |
-| `->autoIncrement()` | Set `INTEGER` columns as auto-incrementing (primary key). |
-| `->charset('utf8mb4')` | Specify a character set for the column (MariaDB / MySQL). |
-| `->collation('utf8mb4_unicode_ci')` | Specify a collation for the column. |
-| `->comment('my comment')` | Add a comment to a column (MariaDB / MySQL / PostgreSQL). |
-| `->default($value)` | Specify a "default" value for the column. |
-| `->first()` | Place the column "first" in the table (MariaDB / MySQL). |
-| `->from($integer)` | Set the starting value of an auto-incrementing field (MariaDB / MySQL / PostgreSQL). |
-| `->invisible()` | Make the column "invisible" to `SELECT *` queries (MariaDB / MySQL). |
-| `->nullable($value = true)` | Allow `NULL` values to be inserted into the column. |
-| `->storedAs($expression)` | Create a stored generated column (MariaDB / MySQL / PostgreSQL / SQLite). |
-| `->unsigned()` | Set `INTEGER` columns as `UNSIGNED` (MariaDB / MySQL). |
-| `->useCurrent()` | Set `TIMESTAMP` columns to use `CURRENT_TIMESTAMP` as default value. |
-| `->useCurrentOnUpdate()` | Set `TIMESTAMP` columns to use `CURRENT_TIMESTAMP` when a record is updated (MariaDB / MySQL). |
-| `->virtualAs($expression)` | Create a virtual generated column (MariaDB / MySQL / SQLite). |
-| `->generatedAs($expression)` | Create an identity column with specified sequence options (PostgreSQL). |
-| `->always()` | Defines the precedence of sequence values over input for an identity column (PostgreSQL). |
-
-
-
-#### Default Expressions
-
-The `default` modifier accepts a value or an `Hyperf\Database\Query\Expression` instance. Using an `Expression` instance will prevent Hypervel from wrapping the value in quotes and allow you to use database specific functions. One situation where this is particularly useful is when you need to assign default values to JSON columns:
-
-```php
-id();
- $table->json('movies')->default(new Expression('(JSON_ARRAY())'));
- $table->timestamps();
- });
- }
-};
-```
-
-::: warning
-Support for default expressions depends on your database driver, database version, and the field type. Please refer to your database's documentation.
-:::
-
-#### Column Order
-
-When using the MariaDB or MySQL database, the `after` method may be used to add columns after an existing column in the schema:
-
-```php
-$table->after('password', function (Blueprint $table) {
- $table->string('address_line1');
- $table->string('address_line2');
- $table->string('city');
-});
-```
-
-### Modifying Columns
-
-The `change` method allows you to modify the type and attributes of existing columns. For example, you may wish to increase the size of a `string` column. To see the `change` method in action, let's increase the size of the `name` column from 25 to 50. To accomplish this, we simply define the new state of the column and then call the `change` method:
-
-```php
-Schema::table('users', function (Blueprint $table) {
- $table->string('name', 50)->change();
-});
-```
-
-When modifying a column, you must explicitly include all the modifiers you want to keep on the column definition - any missing attribute will be dropped. For example, to retain the `unsigned`, `default`, and `comment` attributes, you must call each modifier explicitly when changing the column:
-
-```php
-Schema::table('users', function (Blueprint $table) {
- $table->integer('votes')->unsigned()->default(1)->comment('my comment')->change();
-});
-```
-
-The `change` method does not change the indexes of the column. Therefore, you may use index modifiers to explicitly add or drop an index when modifying the column:
-
-```php
-// Add an index...
-$table->bigIncrements('id')->primary()->change();
-
-// Drop an index...
-$table->char('postal_code', 10)->unique(false)->change();
-```
-
-### Renaming Columns
-
-To rename a column, you may use the `renameColumn` method provided by the schema builder:
-
-```php
-Schema::table('users', function (Blueprint $table) {
- $table->renameColumn('from', 'to');
-});
-```
-
-### Dropping Columns
-
-To drop a column, you may use the `dropColumn` method on the schema builder:
-
-```php
-Schema::table('users', function (Blueprint $table) {
- $table->dropColumn('votes');
-});
-```
-
-You may drop multiple columns from a table by passing an array of column names to the `dropColumn` method:
-
-```php
-Schema::table('users', function (Blueprint $table) {
- $table->dropColumn(['votes', 'avatar', 'location']);
-});
-```
-
-#### Available Command Aliases
-
-Hypervel provides several convenient methods related to dropping common types of columns. Each of these methods is described in the table below:
-
-
-
-| Command | Description |
-| ----------------------------------- | ----------------------------------------------------- |
-| `$table->dropMorphs('morphable');` | Drop the `morphable_id` and `morphable_type` columns. |
-| `$table->dropRememberToken();` | Drop the `remember_token` column. |
-| `$table->dropSoftDeletes();` | Drop the `deleted_at` column. |
-| `$table->dropSoftDeletesTz();` | Alias of `dropSoftDeletes()` method. |
-| `$table->dropTimestamps();` | Drop the `created_at` and `updated_at` columns. |
-| `$table->dropTimestampsTz();` | Alias of `dropTimestamps()` method. |
-
-
-
-## Indexes
-
-### Creating Indexes
-
-The Hypervel schema builder supports several types of indexes. The following example creates a new `email` column and specifies that its values should be unique. To create the index, we can chain the `unique` method onto the column definition:
-
-```php
-use Hyperf\Database\Schema\Blueprint;
-use Hypervel\Support\Facades\Schema;
-
-Schema::table('users', function (Blueprint $table) {
- $table->string('email')->unique();
-});
-```
-
-Alternatively, you may create the index after defining the column. To do so, you should call the `unique` method on the schema builder blueprint. This method accepts the name of the column that should receive a unique index:
-
-```php
-$table->unique('email');
-```
-
-You may even pass an array of columns to an index method to create a compound (or composite) index:
-
-```php
-$table->index(['account_id', 'created_at']);
-```
-
-When creating an index, Hypervel will automatically generate an index name based on the table, column names, and the index type, but you may pass a second argument to the method to specify the index name yourself:
-
-```php
-$table->unique('email', 'unique_email');
-```
-
-#### Available Index Types
-
-Hypervel's schema builder blueprint class provides methods for creating each type of index supported by Hypervel. Each index method accepts an optional second argument to specify the name of the index. If omitted, the name will be derived from the names of the table and column(s) used for the index, as well as the index type. Each of the available index methods is described in the table below:
-
-
-
-| Command | Description |
-| ------------------------------------------------ | -------------------------------------------------------------- |
-| `$table->primary('id');` | Adds a primary key. |
-| `$table->primary(['id', 'parent_id']);` | Adds composite keys. |
-| `$table->unique('email');` | Adds a unique index. |
-| `$table->index('state');` | Adds an index. |
-| `$table->fullText('body');` | Adds a full text index (MariaDB / MySQL / PostgreSQL). |
-| `$table->fullText('body')->language('english');` | Adds a full text index of the specified language (PostgreSQL). |
-| `$table->spatialIndex('location');` | Adds a spatial index (except SQLite). |
-
-
-
-
-### Renaming Indexes
-
-To rename an index, you may use the `renameIndex` method provided by the schema builder blueprint. This method accepts the current index name as its first argument and the desired name as its second argument:
-
-```php
-$table->renameIndex('from', 'to')
-```
-
-### Dropping Indexes
-
-To drop an index, you must specify the index's name. By default, Hypervel automatically assigns an index name based on the table name, the name of the indexed column, and the index type. Here are some examples:
-
-
-
-| Command | Description |
-| -------------------------------------------------------- | ----------------------------------------------------------- |
-| `$table->dropPrimary('users_id_primary');` | Drop a primary key from the "users" table. |
-| `$table->dropUnique('users_email_unique');` | Drop a unique index from the "users" table. |
-| `$table->dropIndex('geo_state_index');` | Drop a basic index from the "geo" table. |
-| `$table->dropFullText('posts_body_fulltext');` | Drop a full text index from the "posts" table. |
-| `$table->dropSpatialIndex('geo_location_spatialindex');` | Drop a spatial index from the "geo" table (except SQLite). |
-
-
-
-If you pass an array of columns into a method that drops indexes, the conventional index name will be generated based on the table name, columns, and index type:
-
-```php
-Schema::table('geo', function (Blueprint $table) {
- $table->dropIndex(['state']); // Drops index 'geo_state_index'
-});
-```
-
-### Foreign Key Constraints
-
-Hypervel also provides support for creating foreign key constraints, which are used to force referential integrity at the database level. For example, let's define a `user_id` column on the `posts` table that references the `id` column on a `users` table:
-
-```php
-use Hyperf\Database\Schema\Blueprint;
-use Hypervel\Support\Facades\Schema;
-
-Schema::table('posts', function (Blueprint $table) {
- $table->unsignedBigInteger('user_id');
-
- $table->foreign('user_id')->references('id')->on('users');
-});
-```
-
-Since this syntax is rather verbose, Hypervel provides additional, terser methods that use conventions to provide a better developer experience. When using the `foreignId` method to create your column, the example above can be rewritten like so:
-
-```php
-Schema::table('posts', function (Blueprint $table) {
- $table->foreignId('user_id')->constrained();
-});
-```
-
-The `foreignId` method creates an `UNSIGNED BIGINT` equivalent column, while the `constrained` method will use conventions to determine the table and column being referenced. If your table name does not match Hypervel's conventions, you may manually provide it to the `constrained` method. In addition, the name that should be assigned to the generated index may be specified as well:
-
-```php
-Schema::table('posts', function (Blueprint $table) {
- $table->foreignId('user_id')->constrained(
- table: 'users', indexName: 'posts_user_id'
- );
-});
-```
-
-You may also specify the desired action for the "on delete" and "on update" properties of the constraint:
-
-```php
-$table->foreignId('user_id')
- ->constrained()
- ->onUpdate('cascade')
- ->onDelete('cascade');
-```
-
-An alternative, expressive syntax is also provided for these actions:
-
-
-
-| Method | Description |
-| ----------------------------- | ------------------------------------------------- |
-| `$table->cascadeOnUpdate();` | Updates should cascade. |
-| `$table->restrictOnUpdate();` | Updates should be restricted. |
-| `$table->nullOnUpdate();` | Updates should set the foreign key value to null. |
-| `$table->noActionOnUpdate();` | No action on updates. |
-| `$table->cascadeOnDelete();` | Deletes should cascade. |
-| `$table->restrictOnDelete();` | Deletes should be restricted. |
-| `$table->nullOnDelete();` | Deletes should set the foreign key value to null. |
-| `$table->noActionOnDelete();` | Prevents deletes if child records exist. |
-
-
-
-Any additional [column modifiers](#column-modifiers) must be called before the `constrained` method:
-
-```php
-$table->foreignId('user_id')
- ->nullable()
- ->constrained();
-```
-
-#### Dropping Foreign Keys
-
-To drop a foreign key, you may use the `dropForeign` method, passing the name of the foreign key constraint to be deleted as an argument. Foreign key constraints use the same naming convention as indexes. In other words, the foreign key constraint name is based on the name of the table and the columns in the constraint, followed by a "\_foreign" suffix:
-
-```php
-$table->dropForeign('posts_user_id_foreign');
-```
-
-Alternatively, you may pass an array containing the column name that holds the foreign key to the `dropForeign` method. The array will be converted to a foreign key constraint name using Hypervel's constraint naming conventions:
-
-```php
-$table->dropForeign(['user_id']);
-```
-
-#### Toggling Foreign Key Constraints
-
-You may enable or disable foreign key constraints within your migrations by using the following methods:
-
-```php
-Schema::enableForeignKeyConstraints();
-
-Schema::disableForeignKeyConstraints();
-
-Schema::withoutForeignKeyConstraints(function () {
- // Constraints disabled within this closure...
-});
-```
-
-::: warning
-SQLite disables foreign key constraints by default. When using SQLite, make sure to [enable foreign key support](/docs/database#configuration) in your database configuration before attempting to create them in your migrations.
-:::
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/mocking.md b/_archive/docs/0.3/docs/mocking.md
deleted file mode 100644
index 51057e124a..0000000000
--- a/_archive/docs/0.3/docs/mocking.md
+++ /dev/null
@@ -1,470 +0,0 @@
-# Mocking
-[[toc]]
-
-## Introduction
-
-When testing Hypervel applications, you may wish to "mock" certain aspects of your application so they are not actually executed during a given test. For example, when testing a controller that dispatches an event, you may wish to mock the event listeners so they are not actually executed during the test. This allows you to only test the controller's HTTP response without worrying about the execution of the event listeners, since the event listeners can be tested in their own test case.
-
-Hypervel provides helpers for mocking events, jobs, and facades out of the box. These helpers primarily provide a convenience layer over Mockery so you do not have to manually make complicated Mockery method calls. You can also use [Mockery](http://docs.mockery.io/en/latest/) or PHPUnit to create your own mocks or spies.
-
-## Mocking Objects
-
-When mocking an object that is going to be injected into your application via Hypervel's service container, you will need to bind your mocked instance into the container as an `instance` binding. This will instruct the container to use your mocked instance of the object instead of constructing the object itself:
-
-```php
-use App\Service;
-use Mockery;
-
-$this->instance(Service::class, Mockery::mock(Service::class, function ($mock) {
- $mock->shouldReceive('process')->once();
-}));
-```
-
-In order to make this more convenient, you may use the `mock` method, which is provided by Hypervel's base test case class:
-
-```php
-use App\Service;
-
-$this->mock(Service::class, function ($mock) {
- $mock->shouldReceive('process')->once();
-});
-```
-
-You may use the `partialMock` method when you only need to mock a few methods of an object. The methods that are not mocked will be executed normally when called:
-
-```php
-use App\Service;
-
-$this->partialMock(Service::class, function ($mock) {
- $mock->shouldReceive('process')->once();
-});
-```
-
-Similarly, if you want to spy on an object, Hypervel's base test case class offers a `spy` method as a convenient wrapper around the `Mockery::spy` method:
-
-```php
-use App\Service;
-
-$this->spy(Service::class, function ($mock) {
- $mock->shouldHaveReceived('process');
-});
-```
-
-## Bus Fake
-
-As an alternative to mocking, you may use the `Bus` facade's `fake` method to prevent jobs from being dispatched. When using fakes, assertions are made after the code under test is executed:
-
-```php
-order->id === $order->id;
- });
-
- // Assert a job was not dispatched...
- Bus::assertNotDispatched(AnotherJob::class);
- }
-}
-```
-
-## Event Fake
-
-As an alternative to mocking, you may use the `Event` facade's `fake` method to prevent all event listeners from executing. You may then assert that events were dispatched and even inspect the data they received. When using fakes, assertions are made after the code under test is executed:
-
-```php
-order->id === $order->id;
- });
-
- // Assert an event was dispatched twice...
- Event::assertDispatched(OrderShipped::class, 2);
-
- // Assert an event was not dispatched...
- Event::assertNotDispatched(OrderFailedToShip::class);
- }
-}
-```
-
-::: note
-After calling `Event::fake()`, no event listeners will be executed. So, if your tests use model factories that rely on events, such as creating a UUID during a model's `creating` event, you should call `Event::fake()` **after** using your factories.
-:::
-
-#### Faking A Subset Of Events
-
-If you only want to fake event listeners for a specific set of events, you may pass them to the `fake` or `fakeFor` method:
-
-```php
-/**
- * Test order process.
- */
-public function testOrderProcess()
-{
- Event::fake([
- OrderCreated::class,
- ]);
-
- $order = factory(Order::class)->create();
-
- Event::assertDispatched(OrderCreated::class);
-
- // Other events are dispatched as normal...
- $order->update([...]);
-}
-```
-
-### Scoped Event Fakes
-
-If you only want to fake event listeners for a portion of your test, you may use the `fakeFor` method:
-
-```php
-create();
-
- Event::assertDispatched(OrderCreated::class);
-
- return $order;
- });
-
- // Events are dispatched as normal and observers will run ...
- $order->update([...]);
- }
-}
-```
-
-## HTTP Fake
-
-The `Http` facade's `fake` method allows you to instruct the HTTP client to return stubbed / dummy responses when requests are made. For more information on faking outgoing HTTP requests, please consult the [HTTP Client testing documentation](/docs/http-client#testing).
-
-## Mail Fake
-
-You may use the `Mail` facade's `fake` method to prevent mail from being sent. You may then assert that [mailables](/docs/mail) were sent to users and even inspect the data they received. When using fakes, assertions are made after the code under test is executed:
-
-```php
-order->id === $order->id;
- });
-
- // Assert a message was sent to the given users...
- Mail::assertSent(OrderShipped::class, function ($mail) use ($user) {
- return $mail->hasTo($user->email) &&
- $mail->hasCc('...') &&
- $mail->hasBcc('...');
- });
-
- // Assert a mailable was sent twice...
- Mail::assertSent(OrderShipped::class, 2);
-
- // Assert a mailable was not sent...
- Mail::assertNotSent(AnotherMailable::class);
- }
-}
-```
-
-If you are queueing mailables for delivery in the background, you should use the `assertQueued` method instead of `assertSent`:
-
-```php
-Mail::assertQueued(...);
-Mail::assertNotQueued(...);
-```
-
-## Notification Fake
-
-You may use the `Notification` facade's `fake` method to prevent notifications from being sent. You may then assert that [notifications](/docs/notifications) were sent to users and even inspect the data they received. When using fakes, assertions are made after the code under test is executed:
-
-```php
-order->id === $order->id;
- }
- );
-
- // Assert a notification was sent to the given users...
- Notification::assertSentTo(
- [$user], OrderShipped::class
- );
-
- // Assert a notification was not sent...
- Notification::assertNotSentTo(
- [$user], AnotherNotification::class
- );
-
- // Assert a notification was sent via Notification::route() method...
- Notification::assertSentTo(
- new AnonymousNotifiable, OrderShipped::class
- );
-
- // Assert Notification::route() method sent notification to the correct user...
- Notification::assertSentTo(
- new AnonymousNotifiable,
- OrderShipped::class,
- function ($notification, $channels, $notifiable) use ($user) {
- return $notifiable->routes['mail'] === $user->email;
- }
- );
- }
-}
-```
-
-## Queue Fake
-
-As an alternative to mocking, you may use the `Queue` facade's `fake` method to prevent jobs from being queued. You may then assert that jobs were pushed to the queue and even inspect the data they received. When using fakes, assertions are made after the code under test is executed:
-
-```php
-order->id === $order->id;
- });
-
- // Assert a job was pushed to a given queue...
- Queue::assertPushedOn('queue-name', ShipOrder::class);
-
- // Assert a job was pushed twice...
- Queue::assertPushed(ShipOrder::class, 2);
-
- // Assert a job was not pushed...
- Queue::assertNotPushed(AnotherJob::class);
-
- // Assert a job was pushed with a given chain of jobs, matching by class...
- Queue::assertPushedWithChain(ShipOrder::class, [
- AnotherJob::class,
- FinalJob::class
- ]);
-
- // Assert a job was pushed with a given chain of jobs, matching by both class and properties...
- Queue::assertPushedWithChain(ShipOrder::class, [
- new AnotherJob('foo'),
- new FinalJob('bar'),
- ]);
-
- // Assert a job was pushed without a chain of jobs...
- Queue::assertPushedWithoutChain(ShipOrder::class);
- }
-}
-```
-
-## Storage Fake
-
-The `Storage` facade's `fake` method allows you to easily generate a fake disk that, combined with the file generation utilities of the `UploadedFile` class, greatly simplifies the testing of file uploads. For example:
-
-```php
-json('POST', '/photos', [
- UploadedFile::fake()->image('photo1.jpg'),
- UploadedFile::fake()->image('photo2.jpg')
- ]);
-
- // Assert one or more files were stored...
- Storage::disk('photos')->assertExists('photo1.jpg');
- Storage::disk('photos')->assertExists(['photo1.jpg', 'photo2.jpg']);
-
- // Assert one or more files were not stored...
- Storage::disk('photos')->assertMissing('missing.jpg');
- Storage::disk('photos')->assertMissing(['missing.jpg', 'non-existing.jpg']);
- }
-}
-```
-
-::: tip
-By default, the `fake` method will delete all files in its temporary directory. If you would like to keep these files, you may use the "persistentFake" method instead.
-:::
-
-## Facades
-
-Unlike traditional static method calls, [facades](/docs/facades) may be mocked. This provides a great advantage over traditional static methods and grants you the same testability you would have if you were using dependency injection. When testing, you may often want to mock a call to a Hypervel facade in one of your controllers. For example, consider the following controller action:
-
-```php
-once()
- ->with('key')
- ->andReturn('value');
-
- $response = $this->get('/users');
-
- // ...
- }
-}
-```
-
-::: note
-You should not mock the `Request` facade. Instead, pass the input you desire into the HTTP helper methods such as `get` and `post` when running your test. Likewise, instead of mocking the `Config` facade, call the `Config::set` method in your tests.
-:::
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/nested-set.md b/_archive/docs/0.3/docs/nested-set.md
deleted file mode 100644
index 12acc52005..0000000000
--- a/_archive/docs/0.3/docs/nested-set.md
+++ /dev/null
@@ -1,727 +0,0 @@
-# Hypervel Nested Set
-
-[[toc]]
-
-## Introduction
-
-Most web applications need to store and work with hierarchical data at some point. Whether you're building a menu system, organizing product categories, or managing organizational structures, you'll eventually face the challenge of efficiently querying tree-like data in a relational database.
-
-The Hypervel Nested Set package provides a robust solution for managing hierarchical data using the nested set model - a technique that stores tree structures in a way that makes retrieving entire subtrees, checking ancestry relationships, and performing complex hierarchical queries remarkably efficient. This package is ported from [Lazychaser's Nested Set package](https://github.com/lazychaser/laravel-nestedset) and optimized for the Hypervel framework. Unlike traditional parent-child relationships that require recursive queries or multiple database hits, nested sets allow you to fetch an entire category tree or determine if a node is an ancestor of another with a single, simple query.
-
-This package handles all the complexity of maintaining the tree structure behind the scenes. When you move a node or insert new children, the package automatically recalculates the internal boundaries that make fast queries possible. You can focus on your application logic while the package ensures your tree data remains consistent and performant.
-
-### When to Use Nested Set
-
-**Best for:**
-- Menu systems and navigation hierarchies
-- Category trees (product categories, content taxonomies)
-- Organizational charts and reporting structures
-- Comment threads and discussions
-- File/folder hierarchies
-- Geographic hierarchies (country > state > city)
-
-**Consider alternatives when:**
-- Tree structure changes frequently (many insertions/updates)
-- You primarily need parent-child relationships without deep querying
-- Simple adjacency lists are sufficient for your use case
-
-## Installation
-
-Install the package via Composer:
-
-```bash
-composer require hypervel/nested-set
-```
-
-## Setup
-
-### Database Migration
-
-Add the nested set columns to your table using the provided helper:
-
-```php
-use Hyperf\Database\Schema\Blueprint;
-use Hypervel\Database\Migrations\Migration;
-use Hypervel\NestedSet\NestedSet;
-use Hypervel\Support\Facades\Schema;
-
-return new class extends Migration
-{
- public function up(): void
- {
- Schema::create('categories', function (Blueprint $table) {
- $table->id();
- $table->string('name');
- $table->text('description')->nullable();
-
- // Add nested set columns
- NestedSet::columns($table);
-
- $table->timestamps();
- });
- }
-
- public function down(): void
- {
- Schema::table('categories', function (Blueprint $table) {
- NestedSet::dropColumns($table);
- });
-
- Schema::dropIfExists('categories');
- }
-};
-```
-
-This creates the following columns:
-- `_lft` (unsigned integer) - Left boundary
-- `_rgt` (unsigned integer) - Right boundary
-- `parent_id` (unsigned integer, nullable) - Parent node ID
-
-### Model Setup
-
-Add the `HasNode` trait to your model:
-
-```php
-namespace App\Models;
-
-use Hypervel\Database\Eloquent\Model;
-use Hypervel\NestedSet\HasNode;
-
-class Category extends Model
-{
- use HasNode;
-
- protected array $fillable = [
- 'name',
- 'description',
- ];
-}
-```
-
-## Basic Usage
-
-### Creating Root Nodes
-
-```php
-use App\Models\Category;
-
-// Create a root node
-$electronics = Category::create([
- 'name' => 'Electronics'
-]);
-
-// Or explicitly make it root
-$clothing = new Category(['name' => 'Clothing']);
-$clothing->saveAsRoot();
-```
-
-### Creating Child Nodes
-
-```php
-// Append to parent (becomes last child)
-$computers = new Category(['name' => 'Computers']);
-$electronics->appendNode($computers);
-
-// Prepend to parent (becomes first child)
-$phones = new Category(['name' => 'Phones']);
-$electronics->prependNode($phones);
-
-// Alternative syntax
-$laptops = Category::create(['name' => 'Laptops']);
-$laptops->appendToNode($computers);
-
-// Create with parent relationship
-$tablets = Category::create([
- 'name' => 'Tablets',
-], $electronics);
-```
-
-### Moving Nodes
-
-```php
-// Move node to different parent
-$laptops->appendToNode($electronics);
-
-// Insert before another node
-$smartphones = Category::create(['name' => 'Smartphones']);
-$smartphones->beforeNode($tablets);
-
-// Insert after another node
-$smartwatches = Category::create(['name' => 'Smartwatches']);
-$smartwatches->afterNode($smartphones);
-
-// Move up/down among siblings
-$laptops->up(); // Move up one position
-$tablets->down(2); // Move down two positions
-```
-
-## Retrieving Nodes
-
-### Basic Relationships
-
-```php
-$category = Category::find(1);
-
-// Get immediate parent
-$parent = $category->parent;
-
-// Get immediate children
-$children = $category->children;
-
-// Check if node has relationships
-if ($category->isRoot()) {
- // This is a root node
-}
-
-if ($category->isLeaf()) {
- // This node has no children
-}
-```
-
-### Ancestors and Descendants
-
-```php
-// Get all ancestors (parents, grandparents, etc.)
-$ancestors = $category->ancestors()->get();
-$ancestors = $category->getAncestors(); // Alternative
-
-// Get ancestors including self
-$ancestorsAndSelf = $category->ancestorsAndSelf();
-
-// Get all descendants (children, grandchildren, etc.)
-$descendants = $category->descendants()->get();
-$descendants = $category->getDescendants(); // Alternative
-
-// Get descendants including self
-$descendantsAndSelf = $category->descendantsAndSelf();
-
-// Get only direct children
-$directChildren = $category->children()->get();
-```
-
-### Siblings
-
-```php
-// Get siblings (nodes with same parent)
-$siblings = $category->siblings()->get();
-$siblings = $category->getSiblings(); // Alternative
-
-// Get siblings including self
-$siblingsAndSelf = $category->getSiblingsAndSelf();
-
-// Get next/previous siblings
-$nextSiblings = $category->getNextSiblings();
-$prevSiblings = $category->getPrevSiblings();
-
-// Get immediate next/previous sibling
-$nextSibling = $category->getNextSibling();
-$prevSibling = $category->getPrevSibling();
-```
-
-### Advanced Queries
-
-```php
-// Get root nodes only
-$roots = Category::whereIsRoot()->get();
-
-// Get leaf nodes only (no children)
-$leaves = Category::whereIsLeaf()->get();
-
-// Get nodes with children
-$parents = Category::hasChildren()->get();
-
-// Get ancestors of specific node
-$ancestors = Category::ancestorsOf($categoryId);
-
-// Get descendants of specific node
-$descendants = Category::descendantsOf($categoryId);
-
-// Get nodes after specific node
-$afterNodes = Category::whereIsAfter($category)->get();
-
-// Get nodes before specific node
-$beforeNodes = Category::whereIsBefore($category)->get();
-```
-
-## Tree Operations
-
-### Building Trees
-
-#### From Nested Arrays
-
-```php
-$treeData = [
- 'name' => 'Electronics',
- 'children' => [
- [
- 'name' => 'Computers',
- 'children' => [
- ['name' => 'Laptops'],
- ['name' => 'Desktops'],
- ]
- ],
- [
- 'name' => 'Phones',
- 'children' => [
- ['name' => 'iPhones'],
- ['name' => 'Android Phones'],
- ]
- ]
- ]
-];
-
-// Create entire tree structure
-$electronics = Category::create($treeData);
-```
-
-#### Rebuilding Trees
-
-```php
-// Rebuild tree from array data
-$categories = [
- ['id' => 1, 'name' => 'Electronics', 'parent_id' => null],
- ['id' => 2, 'name' => 'Computers', 'parent_id' => 1],
- ['id' => 3, 'name' => 'Laptops', 'parent_id' => 2],
- ['id' => 4, 'name' => 'Phones', 'parent_id' => 1],
-];
-
-Category::rebuildTree($categories);
-
-// Rebuild specific subtree
-Category::rebuildSubtree($electronics, $subtreeData);
-```
-
-### Tree Collections
-
-The package provides specialized collection methods for working with tree data:
-
-```php
-$categories = Category::get();
-
-// Link parent-child relationships
-$categories->linkNodes();
-
-// Convert flat collection to nested tree
-$tree = $categories->toTree();
-
-// Convert to flat tree (ordered hierarchy)
-$flatTree = $categories->toFlatTree();
-```
-
-### Tree Validation and Repair
-
-```php
-// Check for tree errors
-$errors = Category::countErrors();
-/*
-Returns array with error counts:
-[
- 'oddness' => 0, // Invalid lft/rgt values
- 'duplicates' => 0, // Duplicate lft/rgt values
- 'wrong_parent' => 0, // Incorrect parent relationships
- 'missing_parent' => 0 // Missing parent nodes
-]
-*/
-
-// Get total error count
-$totalErrors = Category::getTotalErrors();
-
-// Check if tree is broken
-if (Category::isBroken()) {
- // Fix the entire tree
- $fixed = Category::fixTree();
- echo "Fixed {$fixed} nodes";
-}
-
-// Fix specific subtree
-$fixed = Category::fixSubtree($rootNode);
-```
-
-## Advanced Features
-
-### Depth Information
-
-```php
-// Include depth level in results
-$categoriesWithDepth = Category::withDepth()->get();
-
-foreach ($categoriesWithDepth as $category) {
- echo str_repeat(' ', $category->depth) . $category->name;
-}
-
-// Alternative: calculate depth manually
-$depth = $category->ancestors()->count();
-```
-
-### Scoped Trees
-
-For multiple independent trees in the same table:
-
-```php
-class Category extends Model
-{
- use HasNode;
-
- // Define scope attributes
- protected function getScopeAttributes(): array
- {
- return ['company_id']; // Separate trees per company
- }
-}
-
-// Usage
-$companyCategories = Category::scoped(['company_id' => 1])
- ->defaultOrder()
- ->get();
-
-// All operations automatically respect scope
-$electronics = Category::create([
- 'name' => 'Electronics',
- 'company_id' => 1
-]);
-
-$computers = Category::create([
- 'name' => 'Computers',
- 'company_id' => 1
-]);
-
-$computers->appendToNode($electronics); // Only works within same scope
-```
-
-### Soft Delete Support
-
-The package automatically handles soft deletes:
-
-```php
-class Category extends Model
-{
- use HasNode, SoftDeletes;
-}
-
-// Deleting a node soft-deletes all descendants
-$electronics->delete(); // Soft deletes entire subtree
-
-// Restoring a node restores all descendants deleted with it
-$electronics->restore(); // Restores entire subtree
-
-// Force delete removes from tree structure
-$electronics->forceDelete(); // Permanently removes and adjusts tree
-```
-
-### Custom Node Operations
-
-```php
-class Category extends Model
-{
- use HasNode;
-
- // Custom method using tree relationships
- public function getPath(string $separator = ' > '): string
- {
- return $this->ancestorsAndSelf()
- ->pluck('name')
- ->implode($separator);
- }
-
- // Get total product count including subcategories
- public function getTotalProductCount(): int
- {
- return $this->descendantsAndSelf()
- ->withCount('products')
- ->sum('products_count');
- }
-
- // Check if category can be deleted
- public function canDelete(): bool
- {
- return $this->products()->count() === 0 &&
- $this->descendants()->count() === 0;
- }
-}
-
-// Usage
-echo $category->getPath(); // "Electronics > Computers > Laptops"
-$totalProducts = $category->getTotalProductCount();
-```
-
-## Query Optimization
-
-### Eager Loading
-
-```php
-// Load tree with relationships
-$categories = Category::with([
- 'children',
- 'parent',
- 'products'
-])->get();
-
-// Load ancestors for multiple nodes efficiently
-$categories = Category::with('ancestors')->get();
-```
-
-### Ordering Results
-
-```php
-// Default tree order (by left boundary)
-$categories = Category::defaultOrder()->get();
-
-// Reverse order
-$categories = Category::defaultOrder('desc')->get();
-// or
-$categories = Category::reversed()->get();
-
-// Custom ordering with depth
-$categories = Category::withDepth()
- ->orderBy('depth')
- ->orderBy('name')
- ->get();
-```
-
-### Limiting Results
-
-```php
-// Get only root level
-$roots = Category::whereIsRoot()
- ->withDepth()
- ->where('depth', 0)
- ->get();
-
-// Get specific depth levels
-$topTwoLevels = Category::withDepth()
- ->where('depth', '<=', 2)
- ->get();
-
-// Exclude root from results
-$nonRoots = Category::withoutRoot()->get();
-// or
-$hasParent = Category::hasParent()->get();
-```
-
-## Tree Rendering Examples
-
-### Simple Nested List
-
-```php
-function renderTree($nodes, $depth = 0): string
-{
- $html = $depth === 0 ? '- ' : '
- '; - $html .= '' . $node->name . ''; - - if ($node->children->isNotEmpty()) { - $html .= renderTree($node->children, $depth + 1); - } - - $html .= ' '; - } - - $html .= '
- {{ $error }} - @endforeach -
- ';
-
- foreach ($nodes as $node) {
- $html .= '
-{{ config('app.name') }} -
- @foreach ($users as $user)
- {{ $user->name }}
- @endforeach
-
-
-{{ $users->links() }}
-```
-
-The `links` method will render the links to the rest of the pages in the result set. Each of these links will already contain the proper `page` query string variable.
-
-### Adjusting the Pagination Link Window
-
-When the paginator displays pagination links, the current page number is displayed as well as links for the three pages before and after the current page. Using the `onEachSide` method, you may control how many additional links are displayed on each side of the current page within the middle, sliding window of links generated by the paginator:
-
-```html
-{{ $users->onEachSide(5)->links() }}
-```
-
-### Converting Results to JSON
-
-The Hypervel paginator classes implement the `Hyperf\Contract\Jsonable` Interface contract and expose the `toJson` method, so it's very easy to convert your pagination results to JSON. You may also convert a paginator instance to JSON by returning it from a route or controller action:
-
-```php
-use App\Models\User;
-
-Route::get('/users', function () {
- return User::paginate();
-});
-```
-
-The JSON from the paginator will include meta information such as `total`, `current_page`, `last_page`, and more. The result records are available via the `data` key in the JSON array. Here is an example of the JSON created by returning a paginator instance from a route:
-
-```json
-{
- "total": 50,
- "per_page": 15,
- "current_page": 1,
- "last_page": 4,
- "first_page_url": "http://laravel.app?page=1",
- "last_page_url": "http://laravel.app?page=4",
- "next_page_url": "http://laravel.app?page=2",
- "prev_page_url": null,
- "path": "http://laravel.app",
- "from": 1,
- "to": 15,
- "data":[
- {
- // Record...
- },
- {
- // Record...
- }
- ]
-}
-```
-
-## Paginator / LengthAwarePaginator Instance Methods
-
-Each paginator instance provides additional pagination information via the following methods:
-
-
-
-| Method | Description |
-| --- | --- |
-| `$paginator->count()` | Get the number of items for the current page. |
-| `$paginator->currentPage()` | Get the current page number. |
-| `$paginator->firstItem()` | Get the result number of the first item in the results. |
-| `$paginator->getOptions()` | Get the paginator options. |
-| `$paginator->getUrlRange($start, $end)` | Create a range of pagination URLs. |
-| `$paginator->hasPages()` | Determine if there are enough items to split into multiple pages. |
-| `$paginator->hasMorePages()` | Determine if there are more items in the data store. |
-| `$paginator->items()` | Get the items for the current page. |
-| `$paginator->lastItem()` | Get the result number of the last item in the results. |
-| `$paginator->lastPage()` | Get the page number of the last available page. (Not available when using `simplePaginate`). |
-| `$paginator->nextPageUrl()` | Get the URL for the next page. |
-| `$paginator->onFirstPage()` | Determine if the paginator is on the first page. |
-| `$paginator->perPage()` | The number of items to be shown per page. |
-| `$paginator->previousPageUrl()` | Get the URL for the previous page. |
-| `$paginator->total()` | Determine the total number of matching items in the data store. (Not available when using `simplePaginate`). |
-| `$paginator->url($page)` | Get the URL for a given page number. |
-| `$paginator->getPageName()` | Get the query string variable used to store the page. |
-| `$paginator->setPageName($name)` | Set the query string variable used to store the page. |
-| `$paginator->through($callback)` | Transform each item using a callback. |
-
-
-
-## Cursor Paginator Instance Methods
-
-Each cursor paginator instance provides additional pagination information via the following methods:
-
-
-
-| Method | Description |
-| ------------------------------- | ----------------------------------------------------------------- |
-| `$paginator->count()` | Get the number of items for the current page. |
-| `$paginator->cursor()` | Get the current cursor instance. |
-| `$paginator->getOptions()` | Get the paginator options. |
-| `$paginator->hasPages()` | Determine if there are enough items to split into multiple pages. |
-| `$paginator->hasMorePages()` | Determine if there are more items in the data store. |
-| `$paginator->getCursorName()` | Get the query string variable used to store the cursor. |
-| `$paginator->items()` | Get the items for the current page. |
-| `$paginator->nextCursor()` | Get the cursor instance for the next set of items. |
-| `$paginator->nextPageUrl()` | Get the URL for the next page. |
-| `$paginator->onFirstPage()` | Determine if the paginator is on the first page. |
-| `$paginator->onLastPage()` | Determine if the paginator is on the last page. |
-| `$paginator->perPage()` | The number of items to be shown per page. |
-| `$paginator->previousCursor()` | Get the cursor instance for the previous set of items. |
-| `$paginator->previousPageUrl()` | Get the URL for the previous page. |
-| `$paginator->setCursorName()` | Set the query string variable used to store the cursor. |
-| `$paginator->url($cursor)` | Get the URL for a given cursor instance. |
-
-
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/permission.md b/_archive/docs/0.3/docs/permission.md
deleted file mode 100644
index e9af2fdfca..0000000000
--- a/_archive/docs/0.3/docs/permission.md
+++ /dev/null
@@ -1,676 +0,0 @@
-# Hypervel Permission
-
-[[toc]]
-
-## Introduction
-
-Modern web applications often need to control what users can and cannot do. Whether you're building a content management system where editors can publish articles but only admins can manage users, or an e-commerce platform where different staff members have access to different parts of the system, you'll need a robust way to manage permissions and user roles.
-
-The Hypervel Permission package provides a flexible and powerful solution for implementing role-based access control (RBAC) in your applications. This package is ported from [Spatie's Permission package](https://spatie.be/docs/laravel-permission) but optimized for the Hypervel framework with advanced caching capabilities and support for modern PHP features. Instead of hardcoding permission checks throughout your codebase, you can define roles like "editor" or "admin", assign specific permissions to those roles, and then simply check if a user has the required role or permission. The package handles all the complex database queries and caching behind the scenes.
-
-What makes this package particularly powerful is its flexibility - you can assign roles to users for broad access control, assign specific permissions for fine-grained control, or even use "forbidden permissions" to explicitly deny access to certain actions. All permission checks are optimized with intelligent caching, so you don't have to worry about performance even with complex permission hierarchies.
-
-## Installation
-
-You can install the permission package via Composer:
-
-```bash
-composer require hypervel/permission
-```
-
-The package will automatically register its service provider.
-
-### Publishing Assets
-
-Publish the migration and configuration files:
-
-```bash
-php artisan vendor:publish "Hypervel\Permission\PermissionServiceProvider"
-```
-
-Or publish them separately:
-
-```bash
-# Publish config only
-php artisan vendor:publish "Hypervel\Permission\PermissionServiceProvider" --tag="permission-config"
-
-# Publish migrations only
-php artisan vendor:publish "Hypervel\Permission\PermissionServiceProvider" --tag="permission-migrations"
-```
-
-### Running Migrations
-
-After publishing, run the migrations to create the necessary tables:
-
-```bash
-php artisan migrate
-```
-
-This will create the following tables:
-- `roles` - stores role information
-- `permissions` - stores permission information
-- `role_has_permissions` - pivot table for role-permission relationships
-- `owner_has_permissions` - polymorphic table for model-permission relationships
-- `owner_has_roles` - polymorphic table for model-role relationships
-
-## Configuration
-
-The package configuration file `config/permission.php` allows you to customize various aspects:
-
-### Models
-
-You can specify custom models for roles and permissions:
-
-```php
-'models' => [
- 'role' => \App\Models\Role::class,
- 'permission' => \App\Models\Permission::class,
-],
-```
-
-### Table Names
-
-Customize table names to match your database schema:
-
-```php
-'table_names' => [
- 'roles' => 'roles',
- 'permissions' => 'permissions',
- 'role_has_permissions' => 'role_has_permissions',
- 'owner_has_permissions' => 'owner_has_permissions',
- 'owner_has_roles' => 'owner_has_roles',
-],
-```
-
-### Column Names
-
-Customize column names used in relationships:
-
-```php
-'column_names' => [
- 'role_pivot_key' => 'role_id',
- 'permission_pivot_key' => 'permission_id',
- 'owner_morph_key' => 'owner_id',
- 'owner_name' => 'owner',
-],
-```
-
-### Cache Configuration
-
-Configure caching behavior for optimal performance:
-
-```php
-'cache' => [
- 'expiration_seconds' => 86400, // 24 hours
- 'keys' => [
- 'roles' => 'hypervel.permission.cache.roles',
- 'owner_roles' => 'hypervel.permission.cache.owner.roles',
- 'owner_permissions' => 'hypervel.permission.cache.owner.permissions',
- ],
- 'store' => env('PERMISSION_CACHE_STORE', 'default'),
-],
-```
-
-## Basic Usage
-
-### Adding Traits to Models
-
-To use permissions and roles with your models, add the appropriate traits:
-
-#### For Users (or any model that should have roles and permissions):
-
-```php
-namespace App\Models;
-
-use Hypervel\Database\Eloquent\Model;
-use Hypervel\Permission\Traits\HasRole;
-
-class User extends Model
-{
- use HasRole; // This also includes HasPermission trait
-
- // Your model code...
-}
-```
-
-#### For Custom Permission Model:
-
-```php
-namespace App\Models;
-
-use Hypervel\Permission\Models\Permission as BasePermission;
-
-class Permission extends BasePermission
-{
- // Add custom methods or properties
-}
-```
-
-#### For Custom Role Model:
-
-```php
-namespace App\Models;
-
-use Hypervel\Permission\Models\Role as BaseRole;
-
-class Role extends BaseRole
-{
- // Add custom methods or properties
-}
-```
-
-### Creating Permissions and Roles
-
-#### Creating Permissions
-
-```php
-use Hypervel\Permission\Models\Permission;
-
-// Create permissions
-$permission = Permission::create(['name' => 'edit articles', 'guard_name' => 'web']);
-$permission = Permission::create(['name' => 'delete articles', 'guard_name' => 'web']);
-$permission = Permission::create(['name' => 'publish articles', 'guard_name' => 'web']);
-```
-
-#### Creating Roles
-
-```php
-use Hypervel\Permission\Models\Role;
-
-// Create roles
-$role = Role::create(['name' => 'writer', 'guard_name' => 'web']);
-$role = Role::create(['name' => 'editor', 'guard_name' => 'web']);
-$role = Role::create(['name' => 'admin', 'guard_name' => 'web']);
-```
-
-#### Assigning Permissions to Roles
-
-```php
-// Assign permissions to roles
-$role = Role::findByName('writer');
-$role->givePermissionTo('edit articles');
-
-// Assign multiple permissions
-$role->givePermissionTo(['edit articles', 'delete articles']);
-
-// Sync permissions (replaces all existing permissions)
-$role->syncPermissions(['edit articles', 'publish articles']);
-```
-
-## Working with Roles
-
-### Assigning Roles to Models
-
-```php
-// Assign a role to a user
-$user->assignRole('writer');
-
-// Assign multiple roles
-$user->assignRole(['writer', 'editor']);
-
-// You can also use IDs
-$user->assignRole(1);
-
-// Sync roles (replaces all existing roles)
-$user->syncRoles(['writer', 'editor']);
-```
-
-### Checking Roles
-
-```php
-// Check if user has a specific role
-if ($user->hasRole('writer')) {
- // User has writer role
-}
-
-// Check if user has any of the specified roles
-if ($user->hasAnyRoles(['writer', 'editor'])) {
- // User has at least one of these roles
-}
-
-// Check if user has all specified roles
-if ($user->hasAllRoles(['writer', 'editor'])) {
- // User has both roles
-}
-
-// Get specific roles that match
-$matchingRoles = $user->onlyRoles(['writer', 'admin']);
-```
-
-### Removing Roles
-
-```php
-// Remove a role
-$user->removeRole('writer');
-
-// Remove multiple roles
-$user->removeRole(['writer', 'editor']);
-```
-
-## Working with Permissions
-
-### Assigning Permissions to Models
-
-```php
-// Give permission directly to user
-$user->givePermissionTo('edit articles');
-
-// Give multiple permissions
-$user->givePermissionTo(['edit articles', 'delete articles']);
-
-// Sync permissions (replaces all existing permissions)
-$user->syncPermissions(['edit articles', 'publish articles']);
-```
-
-### Checking Permissions
-
-```php
-// Check if user has a specific permission
-if ($user->hasPermission('edit articles')) {
- // User has permission (either direct or via role)
-}
-
-// Check direct permissions only
-if ($user->hasDirectPermission('edit articles')) {
- // User has direct permission (not via role)
-}
-
-// Check if user has permission via roles
-if ($user->hasPermissionViaRoles('edit articles')) {
- // User has permission through assigned roles
-}
-
-// Check if user has any of the specified permissions
-if ($user->hasAnyPermissions(['edit articles', 'delete articles'])) {
- // User has at least one permission
-}
-
-// Check if user has all specified permissions
-if ($user->hasAllPermissions(['edit articles', 'delete articles'])) {
- // User has all permissions
-}
-```
-
-### Forbidden Permissions
-
-The package supports forbidden permissions that explicitly deny access:
-
-```php
-// Give forbidden permission (denies access)
-$user->giveForbiddenTo('delete articles');
-
-// Check if user has forbidden permission
-if ($user->hasForbiddenPermission('delete articles')) {
- // Access is explicitly denied
-}
-
-// Forbidden permissions override allowed permissions
-$user->givePermissionTo('delete articles');
-$user->giveForbiddenTo('delete articles');
-// hasPermission('delete articles') will return false
-```
-
-### Revoking Permissions
-
-```php
-// Revoke permission
-$user->revokePermissionTo('edit articles');
-
-// Revoke multiple permissions
-$user->revokePermissionTo(['edit articles', 'delete articles']);
-```
-
-### Getting All Permissions
-
-```php
-// Get all permissions (direct + via roles, excluding forbidden)
-$permissions = $user->getAllPermissions();
-
-// Get permissions via roles only
-$rolePermissions = $user->getPermissionsViaRoles();
-```
-
-## Using Enums
-
-The package supports PHP 8.1+ enums for type-safe permission and role management:
-
-### Backed Enums
-
-```php
-enum Permission: string
-{
- case EDIT_ARTICLES = 'edit articles';
- case DELETE_ARTICLES = 'delete articles';
- case PUBLISH_ARTICLES = 'publish articles';
-}
-
-enum Role: string
-{
- case WRITER = 'writer';
- case EDITOR = 'editor';
- case ADMIN = 'admin';
-}
-
-// Usage with enums
-$user->assignRole(Role::WRITER);
-$user->givePermissionTo(Permission::EDIT_ARTICLES);
-
-if ($user->hasPermission(Permission::EDIT_ARTICLES)) {
- // User can edit articles
-}
-```
-
-### Unit Enums
-
-```php
-enum SimplePermission
-{
- case EDIT_ARTICLES;
- case DELETE_ARTICLES;
- case PUBLISH_ARTICLES;
-}
-
-// The enum name will be used as the permission name
-$user->givePermissionTo(SimplePermission::EDIT_ARTICLES);
-```
-
-## Middleware
-
-The package provides middleware for protecting routes based on roles and permissions.
-
-### Permission Middleware
-
-```php
-use Hypervel\Permission\Middlewares\PermissionMiddleware;
-
-// In your route definitions
-$router->get('/admin', [AdminController::class, 'index'], [
- 'middleware' => [PermissionMiddleware::using('view admin')],
-]);
-
-// Multiple permissions (user needs ANY of them)
-$router->get('/posts/edit', [PostController::class, 'edit'], [
- 'middleware' => [PermissionMiddleware::using('edit articles', 'edit all')],
-]);
-```
-
-### Role Middleware
-
-```php
-use Hypervel\Permission\Middlewares\RoleMiddleware;
-
-// In your route definitions
-$router->get('/admin', [AdminController::class, 'index'], [
- 'middleware' => [RoleMiddleware::using('admin')],
-]);
-
-// Multiple roles (user needs ANY of them)
-$router->get('/editor', [EditorController::class, 'index'], [
- 'middleware' => [RoleMiddleware::using('editor', 'admin')],
-]);
-```
-
-### Using with Enums
-
-```php
-$router->get('/admin', [AdminController::class, 'index'], [
- 'middleware' => [PermissionMiddleware::using(Permission::VIEW_ADMIN)],
-]);
-
-$router->get('/editor', [EditorController::class, 'index'], [
- 'middleware' => [RoleMiddleware::using(Role::EDITOR, Role::ADMIN)],
-]);
-```
-
-## Console Commands
-
-### Viewing Permissions and Roles
-
-Use the built-in command to view the permission matrix:
-
-```bash
-# Show all permissions and roles
-php artisan permission:show
-
-# Show for specific guard
-php artisan permission:show web
-
-# Use different table style
-php artisan permission:show web compact
-```
-
-## Advanced Usage
-
-### Custom Guards
-
-The package supports multiple guards:
-
-```php
-// Create permissions for different guards
-Permission::create(['name' => 'view admin', 'guard_name' => 'web']);
-Permission::create(['name' => 'api access', 'guard_name' => 'api']);
-
-// Roles with different guards
-Role::create(['name' => 'admin', 'guard_name' => 'web']);
-Role::create(['name' => 'api-user', 'guard_name' => 'api']);
-```
-
-### Polymorphic Relationships
-
-The package uses polymorphic relationships, so any model can have roles and permissions:
-
-```php
-class Team extends Model
-{
- use HasRole;
-}
-
-$team = Team::find(1);
-$team->assignRole('project-manager');
-$team->givePermissionTo('manage projects');
-```
-
-### Working with the Permission Manager
-
-The `PermissionManager` class provides advanced functionality:
-
-```php
-use Hypervel\Permission\PermissionManager;
-
-$manager = app(PermissionManager::class);
-
-// Get role and permission classes
-$roleClass = $manager->getRoleClass();
-$permissionClass = $manager->getPermissionClass();
-
-// Cache management
-$manager->clearAllRolesPermissionsCache();
-$manager->clearOwnerCache(User::class, $userId);
-
-// Get cached data
-$allRolesWithPermissions = $manager->getAllRolesWithPermissions();
-$cachedRoles = $manager->getOwnerCachedRoles(User::class, $userId);
-$cachedPermissions = $manager->getOwnerCachedPermissions(User::class, $userId);
-```
-
-### Custom Models
-
-If you want to extend the base models:
-
-```php
-// Custom Permission Model
-class CustomPermission extends \Hypervel\Permission\Models\Permission
-{
- protected array $fillable = ['name', 'guard_name', 'description'];
-
- public function getDescriptionAttribute($value)
- {
- return ucfirst($value);
- }
-}
-
-// Custom Role Model
-class CustomRole extends \Hypervel\Permission\Models\Role
-{
- protected array $fillable = ['name', 'guard_name', 'description'];
-
- public function users()
- {
- return $this->morphedByMany(User::class, 'owner', 'owner_has_roles');
- }
-}
-
-// Update config
-'models' => [
- 'permission' => CustomPermission::class,
- 'role' => CustomRole::class,
-],
-```
-
-## Caching
-
-The package includes sophisticated caching to ensure high performance:
-
-### Cache Strategy
-
-- **All Roles with Permissions**: Cached globally to avoid N+1 queries when checking role-based permissions
-- **Owner Roles**: Individual user/model roles are cached separately
-- **Owner Permissions**: Individual user/model permissions are cached separately
-
-### Cache Invalidation
-
-Cache is automatically cleared when:
-- Roles or permissions are assigned/revoked
-- Role permissions are modified
-- Models with roles/permissions are updated
-
-### Manual Cache Management
-
-```php
-use Hypervel\Permission\PermissionManager;
-
-$manager = app(PermissionManager::class);
-
-// Clear all caches
-$manager->clearAllRolesPermissionsCache();
-
-// Clear specific owner cache
-$manager->clearOwnerCache(User::class, $user->id);
-
-// Get cache store
-$cache = $manager->getCache();
-```
-
-## Performance Considerations
-
-### Optimizing Queries
-
-The package is designed to minimize database queries through caching:
-
-```php
-// This loads and caches all roles with their permissions in one query
-$allRolesWithPermissions = $manager->getAllRolesWithPermissions();
-
-// Subsequent permission checks use cached data
-$user->hasPermissionViaRoles('edit articles'); // No additional queries
-```
-
-### Eager Loading
-
-When working with multiple models, consider eager loading:
-
-```php
-// Load users with their roles and permissions
-$users = User::with(['roles.permissions', 'permissions'])->get();
-
-// Now permission checks won't trigger additional queries
-foreach ($users as $user) {
- if ($user->hasPermission('edit articles')) {
- // Process user
- }
-}
-```
-
-### Cache Warming
-
-For high-traffic applications, warm the cache on deployment:
-
-```php
-use Hypervel\Permission\PermissionManager;
-
-// In a deployment script or command
-$manager = app(PermissionManager::class);
-$manager->getAllRolesWithPermissions(); // Warms the cache
-```
-
-## Common Patterns
-
-### Hierarchical Permissions
-
-```php
-// Create a hierarchy using role inheritance
-$admin = Role::create(['name' => 'admin', 'guard_name' => 'web']);
-$editor = Role::create(['name' => 'editor', 'guard_name' => 'web']);
-$writer = Role::create(['name' => 'writer', 'guard_name' => 'web']);
-
-// Assign cumulative permissions
-$writer->givePermissionTo(['create articles', 'edit own articles']);
-$editor->givePermissionTo(['create articles', 'edit own articles', 'edit all articles', 'publish articles']);
-
-// Users get permissions through role assignment
-$user->assignRole('editor'); // Gets all editor permissions
-```
-
-### Resource-Based Permissions
-
-```php
-// Create permissions for specific resources
-Permission::create(['name' => 'view articles', 'guard_name' => 'web']);
-Permission::create(['name' => 'create articles', 'guard_name' => 'web']);
-Permission::create(['name' => 'edit articles', 'guard_name' => 'web']);
-Permission::create(['name' => 'delete articles', 'guard_name' => 'web']);
-
-Permission::create(['name' => 'view users', 'guard_name' => 'web']);
-Permission::create(['name' => 'create users', 'guard_name' => 'web']);
-Permission::create(['name' => 'edit users', 'guard_name' => 'web']);
-Permission::create(['name' => 'delete users', 'guard_name' => 'web']);
-```
-
-### Dynamic Permission Checking
-
-```php
-class ArticleController extends Controller
-{
- public function show(Article $article)
- {
- // Check if user can view this specific article
- if (!$this->canView($article)) {
- throw new UnauthorizedException('Cannot view this article');
- }
-
- return view('articles.show', compact('article'));
- }
-
- private function canView(Article $article): bool
- {
- $user = auth()->user();
-
- // Admin can view all
- if ($user->hasRole('admin')) {
- return true;
- }
-
- // Users can view published articles
- if ($article->is_published && $user->hasPermission('view articles')) {
- return true;
- }
-
- // Authors can view their own articles
- if ($article->author_id === $user->id && $user->hasPermission('view own articles')) {
- return true;
- }
-
- return false;
- }
-}
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/processes.md b/_archive/docs/0.3/docs/processes.md
deleted file mode 100644
index fa64a017d0..0000000000
--- a/_archive/docs/0.3/docs/processes.md
+++ /dev/null
@@ -1,556 +0,0 @@
-# Processes
-[[toc]]
-
-## Introduction
-
-Hypervel provides an expressive, minimal API around the [Symfony Process component](https://symfony.com/doc/current/components/process.html), allowing you to conveniently invoke external processes from your Hypervel application. Hypervel's process features are focused on the most common use cases and a wonderful developer experience.
-
-## Invoking Processes
-
-To invoke a process, you may use the `run` and `start` methods offered by the `Process` facade. The `run` method will invoke a process and wait for the process to finish executing, while the `start` method is used for asynchronous process execution. We'll examine both approaches within this documentation. First, let's examine how to invoke a basic, synchronous process and inspect its result:
-
-```php
-use Hypervel\Support\Facades\Process;
-
-$result = Process::run('ls -la');
-
-return $result->output();
-```
-
-Of course, the `Hypervel\Process\Contracts\ProcessResult` instance returned by the `run` method offers a variety of helpful methods that may be used to inspect the process result:
-
-```php
-$result = Process::run('ls -la');
-
-$result->successful();
-$result->failed();
-$result->exitCode();
-$result->output();
-$result->errorOutput();
-```
-
-#### Throwing Exceptions
-
-If you have a process result and would like to throw an instance of `Hypervel\Process\Exceptions\ProcessFailedException` if the exit code is greater than zero (thus indicating failure), you may use the `throw` and `throwIf` methods. If the process did not fail, the process result instance will be returned:
-
-```php
-$result = Process::run('ls -la')->throw();
-
-$result = Process::run('ls -la')->throwIf($condition);
-```
-
-### Process Options
-
-Of course, you may need to customize the behavior of a process before invoking it. Thankfully, Hypervel allows you to tweak a variety of process features, such as the working directory, timeout, and environment variables.
-
-#### Working Directory Path
-
-You may use the `path` method to specify the working directory of the process. If this method is not invoked, the process will inherit the working directory of the currently executing PHP script:
-
-```php
-$result = Process::path(__DIR__)->run('ls -la');
-```
-
-#### Input
-
-You may provide input via the "standard input" of the process using the `input` method:
-
-```php
-$result = Process::input('Hello World')->run('cat');
-```
-
-#### Timeouts
-
-By default, processes will throw an instance of `Hypervel\Process\Exceptions\ProcessTimedOutException` after executing for more than 60 seconds. However, you can customize this behavior via the `timeout` method:
-
-```php
-$result = Process::timeout(120)->run('bash import.sh');
-```
-
-Or, if you would like to disable the process timeout entirely, you may invoke the `forever` method:
-
-```php
-$result = Process::forever()->run('bash import.sh');
-```
-
-The `idleTimeout` method may be used to specify the maximum number of seconds the process may run without returning any output:
-
-```php
-$result = Process::timeout(60)->idleTimeout(30)->run('bash import.sh');
-```
-
-#### Environment Variables
-
-Environment variables may be provided to the process via the `env` method. The invoked process will also inherit all of the environment variables defined by your system:
-
-```php
-$result = Process::forever()
- ->env(['IMPORT_PATH' => __DIR__])
- ->run('bash import.sh');
-```
-
-If you wish to remove an inherited environment variable from the invoked process, you may provide that environment variable with a value of `false`:
-
-```php
-$result = Process::forever()
- ->env(['LOAD_PATH' => false])
- ->run('bash import.sh');
-```
-
-#### TTY Mode
-
-The `tty` method may be used to enable TTY mode for your process. TTY mode connects the input and output of the process to the input and output of your program, allowing your process to open an editor like Vim or Nano as a process:
-
-```php
-Process::forever()->tty()->run('vim');
-```
-
-### Process Output
-
-As previously discussed, process output may be accessed using the `output` (stdout) and `errorOutput` (stderr) methods on a process result:
-
-```php
-use Hypervel\Support\Facades\Process;
-
-$result = Process::run('ls -la');
-
-echo $result->output();
-echo $result->errorOutput();
-```
-
-However, output may also be gathered in real-time by passing a closure as the second argument to the `run` method. The closure will receive two arguments: the "type" of output (`stdout` or `stderr`) and the output string itself:
-
-```php
-$result = Process::run('ls -la', function (string $type, string $output) {
- echo $output;
-});
-```
-
-Hypervel also offers the `seeInOutput` and `seeInErrorOutput` methods, which provide a convenient way to determine if a given string was contained in the process' output:
-
-```php
-if (Process::run('ls -la')->seeInOutput('Hypervel')) {
- // ...
-}
-```
-
-#### Disabling Process Output
-
-If your process is writing a significant amount of output that you are not interested in, you can conserve memory by disabling output retrieval entirely. To accomplish this, invoke the `quietly` method while building the process:
-
-```php
-use Hypervel\Support\Facades\Process;
-
-$result = Process::quietly()->run('bash import.sh');
-```
-
-### Pipelines
-
-Sometimes you may want to make the output of one process the input of another process. This is often referred to as "piping" the output of a process into another. The `pipe` method provided by the `Process` facades makes this easy to accomplish. The `pipe` method will execute the piped processes synchronously and return the process result for the last process in the pipeline:
-
-```php
-use Hypervel\Process\Pipe;
-use Hypervel\Support\Facades\Process;
-
-$result = Process::pipe(function (Pipe $pipe) {
- $pipe->command('cat example.txt');
- $pipe->command('grep -i "laravel"');
-});
-
-if ($result->successful()) {
- // ...
-}
-```
-
-If you do not need to customize the individual processes that make up the pipeline, you may simply pass an array of command strings to the `pipe` method:
-
-```php
-$result = Process::pipe([
- 'cat example.txt',
- 'grep -i "laravel"',
-]);
-```
-
-The process output may be gathered in real-time by passing a closure as the second argument to the `pipe` method. The closure will receive two arguments: the "type" of output (`stdout` or `stderr`) and the output string itself:
-
-```php
-$result = Process::pipe(function (Pipe $pipe) {
- $pipe->command('cat example.txt');
- $pipe->command('grep -i "Hypervel"');
-}, function (string $type, string $output) {
- echo $output;
-});
-```
-
-Hypervel also allows you to assign string keys to each process within a pipeline via the `as` method. This key will also be passed to the output closure provided to the `pipe` method, allowing you to determine which process the output belongs to:
-
-```php
-$result = Process::pipe(function (Pipe $pipe) {
- $pipe->as('first')->command('cat example.txt');
- $pipe->as('second')->command('grep -i "laravel"');
-})->start(function (string $type, string $output, string $key) {
- // ...
-});
-```
-
-## Asynchronous Processes
-
-While the `run` method invokes processes synchronously, the `start` method may be used to invoke a process asynchronously. This allows your application to continue performing other tasks while the process runs in the background. Once the process has been invoked, you may utilize the `running` method to determine if the process is still running:
-
-```php
-$process = Process::timeout(120)->start('bash import.sh');
-
-while ($process->running()) {
- // ...
-}
-
-$result = $process->wait();
-```
-
-As you may have noticed, you may invoke the `wait` method to wait until the process is finished executing and retrieve the process result instance:
-
-```php
-$process = Process::timeout(120)->start('bash import.sh');
-
-// ...
-
-$result = $process->wait();
-```
-
-### Process IDs and Signals
-
-The `id` method may be used to retrieve the operating system assigned process ID of the running process:
-
-```php
-$process = Process::start('bash import.sh');
-
-return $process->id();
-```
-
-You may use the `signal` method to send a "signal" to the running process. A list of predefined signal constants can be found within the [PHP documentation](https://www.php.net/manual/en/pcntl.constants.php):
-
-```php
-$process->signal(SIGUSR2);
-```
-
-### Asynchronous Process Output
-
-While an asynchronous process is running, you may access its entire current output using the `output` and `errorOutput` methods; however, you may utilize the `latestOutput` and `latestErrorOutput` to access the output from the process that has occurred since the output was last retrieved:
-
-```php
-$process = Process::timeout(120)->start('bash import.sh');
-
-while ($process->running()) {
- echo $process->latestOutput();
- echo $process->latestErrorOutput();
-
- sleep(1);
-}
-```
-
-Like the `run` method, output may also be gathered in real-time from asynchronous processes by passing a closure as the second argument to the `start` method. The closure will receive two arguments: the "type" of output (`stdout` or `stderr`) and the output string itself:
-
-```php
-$process = Process::start('bash import.sh', function (string $type, string $output) {
- echo $output;
-});
-
-$result = $process->wait();
-```
-
-## Concurrent Processes
-
-Hypervel also makes it a breeze to manage a pool of concurrent, asynchronous processes, allowing you to easily execute many tasks simultaneously. To get started, invoke the `pool` method, which accepts a closure that receives an instance of `Hypervel\Process\Pool`.
-
-Within this closure, you may define the processes that belong to the pool. Once a process pool is started via the `start` method, you may access the [collection](/docs/collections) of running processes via the `running` method:
-
-```php
-use Hypervel\Process\Pool;
-use Hypervel\Support\Facades\Process;
-
-$pool = Process::pool(function (Pool $pool) {
- $pool->path(__DIR__)->command('bash import-1.sh');
- $pool->path(__DIR__)->command('bash import-2.sh');
- $pool->path(__DIR__)->command('bash import-3.sh');
-})->start(function (string $type, string $output, int $key) {
- // ...
-});
-
-while ($pool->running()->isNotEmpty()) {
- // ...
-}
-
-$results = $pool->wait();
-```
-
-As you can see, you may wait for all of the pool processes to finish executing and resolve their results via the `wait` method. The `wait` method returns an array accessible object that allows you to access the process result instance of each process in the pool by its key:
-
-```php
-$results = $pool->wait();
-
-echo $results[0]->output();
-```
-
-Or, for convenience, the `concurrently` method may be used to start an asynchronous process pool and immediately wait on its results. This can provide particularly expressive syntax when combined with PHP's array destructuring capabilities:
-
-```php
-[$first, $second, $third] = Process::concurrently(function (Pool $pool) {
- $pool->path(__DIR__)->command('ls -la');
- $pool->path(app_path())->command('ls -la');
- $pool->path(storage_path())->command('ls -la');
-});
-
-echo $first->output();
-```
-
-### Naming Pool Processes
-
-Accessing process pool results via a numeric key is not very expressive; therefore, Hypervel allows you to assign string keys to each process within a pool via the `as` method. This key will also be passed to the closure provided to the `start` method, allowing you to determine which process the output belongs to:
-
-```php
-$pool = Process::pool(function (Pool $pool) {
- $pool->as('first')->command('bash import-1.sh');
- $pool->as('second')->command('bash import-2.sh');
- $pool->as('third')->command('bash import-3.sh');
-})->start(function (string $type, string $output, string $key) {
- // ...
-});
-
-$results = $pool->wait();
-
-return $results['first']->output();
-```
-
-### Pool Process IDs and Signals
-
-Since the process pool's `running` method provides a collection of all invoked processes within the pool, you may easily access the underlying pool process IDs:
-
-```php
-$processIds = $pool->running()->each->id();
-```
-
-And, for convenience, you may invoke the `signal` method on a process pool to send a signal to every process within the pool:
-
-```php
-$pool->signal(SIGUSR2);
-```
-
-## Testing
-
-Many Hypervel services provide functionality to help you easily and expressively write tests, and Hypervel's process service is no exception. The `Process` facade's `fake` method allows you to instruct Hypervel to return stubbed / dummy results when processes are invoked.
-
-### Faking Processes
-
-To explore Hypervel's ability to fake processes, let's imagine a route that invokes a process:
-
-```php
-use Hypervel\Support\Facades\Process;
-use Hypervel\Support\Facades\Route;
-
-Route::get('/import', function () {
- Process::run('bash import.sh');
-
- return 'Import complete!';
-});
-```
-
-When testing this route, we can instruct Hypervel to return a fake, successful process result for every invoked process by calling the `fake` method on the `Process` facade with no arguments. In addition, we can even [assert](#available-assertions) that a given process was "run":
-
-```php
-get('/import');
-
- // Simple process assertion...
- Process::assertRan('bash import.sh');
-
- // Or, inspecting the process configuration...
- Process::assertRan(function (PendingProcess $process, ProcessResult $result) {
- return $process->command === 'bash import.sh' &&
- $process->timeout === 60;
- });
- }
-}
-```
-
-As discussed, invoking the `fake` method on the `Process` facade will instruct Hypervel to always return a successful process result with no output. However, you may easily specify the output and exit code for faked processes using the `Process` facade's `result` method:
-
-```php
-Process::fake([
- '*' => Process::result(
- output: 'Test output',
- errorOutput: 'Test error output',
- exitCode: 1,
- ),
-]);
-```
-
-### Faking Specific Processes
-
-As you may have noticed in a previous example, the `Process` facade allows you to specify different fake results per process by passing an array to the `fake` method.
-
-The array's keys should represent command patterns that you wish to fake and their associated results. The `*` character may be used as a wildcard character. Any process commands that have not been faked will actually be invoked. You may use the `Process` facade's `result` method to construct stub / fake results for these commands:
-
-```php
-Process::fake([
- 'cat *' => Process::result(
- output: 'Test "cat" output',
- ),
- 'ls *' => Process::result(
- output: 'Test "ls" output',
- ),
-]);
-```
-
-If you do not need to customize the exit code or error output of a faked process, you may find it more convenient to specify the fake process results as simple strings:
-
-```php
-Process::fake([
- 'cat *' => 'Test "cat" output',
- 'ls *' => 'Test "ls" output',
-]);
-```
-
-### Faking Process Sequences
-
-If the code you are testing invokes multiple processes with the same command, you may wish to assign a different fake process result to each process invocation. You may accomplish this via the `Process` facade's `sequence` method:
-
-```php
-Process::fake([
- 'ls *' => Process::sequence()
- ->push(Process::result('First invocation'))
- ->push(Process::result('Second invocation')),
-]);
-```
-
-### Faking Asynchronous Process Lifecycles
-
-Thus far, we have primarily discussed faking processes which are invoked synchronously using the `run` method. However, if you are attempting to test code that interacts with asynchronous processes invoked via `start`, you may need a more sophisticated approach to describing your fake processes.
-
-For example, let's imagine the following route which interacts with an asynchronous process:
-
-```php
-use Hypervel\Support\Facades\Log;
-use Hypervel\Support\Facades\Route;
-
-Route::get('/import', function () {
- $process = Process::start('bash import.sh');
-
- while ($process->running()) {
- Log::info($process->latestOutput());
- Log::info($process->latestErrorOutput());
- }
-
- return 'Done';
-});
-```
-
-To properly fake this process, we need to be able to describe how many times the `running` method should return `true`. In addition, we may want to specify multiple lines of output that should be returned in sequence. To accomplish this, we can use the `Process` facade's `describe` method:
-
-```php
-Process::fake([
- 'bash import.sh' => Process::describe()
- ->output('First line of standard output')
- ->errorOutput('First line of error output')
- ->output('Second line of standard output')
- ->exitCode(0)
- ->iterations(3),
-]);
-```
-
-Let's dig into the example above. Using the `output` and `errorOutput` methods, we may specify multiple lines of output that will be returned in sequence. The `exitCode` method may be used to specify the final exit code of the fake process. Finally, the `iterations` method may be used to specify how many times the `running` method should return `true`.
-
-### Available Assertions
-
-As [previously discussed](#faking-processes), Hypervel provides several process assertions for your feature tests. We'll discuss each of these assertions below.
-
-#### assertRan
-
-Assert that a given process was invoked:
-
-```php
-use Hypervel\Support\Facades\Process;
-
-Process::assertRan('ls -la');
-```
-
-The `assertRan` method also accepts a closure, which will receive an instance of a process and a process result, allowing you to inspect the process' configured options. If this closure returns `true`, the assertion will "pass":
-
-```php
-Process::assertRan(fn ($process, $result) =>
- $process->command === 'ls -la' &&
- $process->path === __DIR__ &&
- $process->timeout === 60
-);
-```
-
-The `$process` passed to the `assertRan` closure is an instance of `Hypervel\Process\PendingProcess`, while the `$result` is an instance of `Hypervel\Process\Contracts\ProcessResult`.
-
-#### assertDidntRun
-
-Assert that a given process was not invoked:
-
-```php
-use Hypervel\Support\Facades\Process;
-
-Process::assertDidntRun('ls -la');
-```
-
-Like the `assertRan` method, the `assertDidntRun` method also accepts a closure, which will receive an instance of a process and a process result, allowing you to inspect the process' configured options. If this closure returns `true`, the assertion will "fail":
-
-```php
-Process::assertDidntRun(fn (PendingProcess $process, ProcessResult $result) =>
- $process->command === 'ls -la'
-);
-```
-
-#### assertRanTimes
-
-Assert that a given process was invoked a given number of times:
-
-```php
-use Hypervel\Support\Facades\Process;
-
-Process::assertRanTimes('ls -la', times: 3);
-```
-
-The `assertRanTimes` method also accepts a closure, which will receive an instance of a process and a process result, allowing you to inspect the process' configured options. If this closure returns `true` and the process was invoked the specified number of times, the assertion will "pass":
-
-```php
-Process::assertRanTimes(function (PendingProcess $process, ProcessResult $result) {
- return $process->command === 'ls -la';
-}, times: 3);
-```
-
-### Preventing Stray Processes
-
-If you would like to ensure that all invoked processes have been faked throughout your individual test or complete test suite, you can call the `preventStrayProcesses` method. After calling this method, any processes that do not have a corresponding fake result will throw an exception rather than starting an actual process:
-
-```php
-use Hypervel\Support\Facades\Process;
-
-Process::preventStrayProcesses();
-
-Process::fake([
- 'ls *' => 'Test output...',
-]);
-
-// Fake response is returned...
-Process::run('ls -la');
-
-// An exception is thrown...
-Process::run('bash import.sh');
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/prompts.md b/_archive/docs/0.3/docs/prompts.md
deleted file mode 100644
index 8849293092..0000000000
--- a/_archive/docs/0.3/docs/prompts.md
+++ /dev/null
@@ -1,949 +0,0 @@
-# Prompts
-[[toc]]
-
-## Introduction
-
-[Hypervel Prompts](https://github.com/hypervel/prompts) is a PHP package for adding beautiful and user-friendly forms to your command-line applications, with browser-like features including placeholder text and validation.
-
-
-
-Hypervel Prompts is perfect for accepting user input in your [Artisan console commands](/docs/artisan#writing-commands), but it may also be used in any command-line PHP project.
-
-## Installation
-
-Hypervel Prompts is already included with the latest release of Hypervel.
-
-Hypervel Prompts may also be installed in your other PHP projects by using the Composer package manager:
-
-```shell
-composer require hypervel/prompts
-```
-
-## Available Prompts
-
-### Text
-
-The `text` function will prompt the user with the given question, accept their input, and then return it:
-
-```php
-use function Hypervel\Prompts\text;
-
-$name = text('What is your name?');
-```
-
-You may also include placeholder text, a default value, and an informational hint:
-
-```php
-$name = text(
- label: 'What is your name?',
- placeholder: 'E.g. Taylor Otwell',
- default: $user?->name,
- hint: 'This will be displayed on your profile.'
-);
-```
-
-#### Required Values
-
-If you require a value to be entered, you may pass the `required` argument:
-
-```php
-$name = text(
- label: 'What is your name?',
- required: true
-);
-```
-
-If you would like to customize the validation message, you may also pass a string:
-
-```php
-$name = text(
- label: 'What is your name?',
- required: 'Your name is required.'
-);
-```
-
-#### Additional Validation
-
-Finally, if you would like to perform additional validation logic, you may pass a closure to the `validate` argument:
-
-```php
-$name = text(
- label: 'What is your name?',
- validate: fn (string $value) => match (true) {
- strlen($value) < 3 => 'The name must be at least 3 characters.',
- strlen($value) > 255 => 'The name must not exceed 255 characters.',
- default => null
- }
-);
-```
-
-The closure will receive the value that has been entered and may return an error message, or `null` if the validation passes.
-
-Alternatively, you may leverage the power of Hypervel's [validator](/docs/validation). To do so, provide an array containing the name of the attribute and the desired validation rules to the `validate` argument:
-
-```php
-$name = text(
- label: 'What is your name?',
- validate: ['name' => 'required|max:255|unique:users']
-);
-```
-
-### Textarea
-
-The `textarea` function will prompt the user with the given question, accept their input via a multi-line textarea, and then return it:
-
-```php
-use function Hypervel\Prompts\textarea;
-
-$story = textarea('Tell me a story.');
-```
-
-You may also include placeholder text, a default value, and an informational hint:
-
-```php
-$story = textarea(
- label: 'Tell me a story.',
- placeholder: 'This is a story about...',
- hint: 'This will be displayed on your profile.'
-);
-```
-
-#### Required Values
-
-If you require a value to be entered, you may pass the `required` argument:
-
-```php
-$story = textarea(
- label: 'Tell me a story.',
- required: true
-);
-```
-
-If you would like to customize the validation message, you may also pass a string:
-
-```php
-$story = textarea(
- label: 'Tell me a story.',
- required: 'A story is required.'
-);
-```
-
-#### Additional Validation
-
-Finally, if you would like to perform additional validation logic, you may pass a closure to the `validate` argument:
-
-```php
-$story = textarea(
- label: 'Tell me a story.',
- validate: fn (string $value) => match (true) {
- strlen($value) < 250 => 'The story must be at least 250 characters.',
- strlen($value) > 10000 => 'The story must not exceed 10,000 characters.',
- default => null
- }
-);
-```
-
-The closure will receive the value that has been entered and may return an error message, or `null` if the validation passes.
-
-Alternatively, you may leverage the power of Hypervel's [validator](/docs/validation). To do so, provide an array containing the name of the attribute and the desired validation rules to the `validate` argument:
-
-```php
-$story = textarea(
- label: 'Tell me a story.',
- validate: ['story' => 'required|max:10000']
-);
-```
-
-### Password
-
-The `password` function is similar to the `text` function, but the user's input will be masked as they type in the console. This is useful when asking for sensitive information such as passwords:
-
-```php
-use function Hypervel\Prompts\password;
-
-$password = password('What is your password?');
-```
-
-You may also include placeholder text and an informational hint:
-
-```php
-$password = password(
- label: 'What is your password?',
- placeholder: 'password',
- hint: 'Minimum 8 characters.'
-);
-```
-
-#### Required Values
-
-If you require a value to be entered, you may pass the `required` argument:
-
-```php
-$password = password(
- label: 'What is your password?',
- required: true
-);
-```
-
-If you would like to customize the validation message, you may also pass a string:
-
-```php
-$password = password(
- label: 'What is your password?',
- required: 'The password is required.'
-);
-```
-
-#### Additional Validation
-
-Finally, if you would like to perform additional validation logic, you may pass a closure to the `validate` argument:
-
-```php
-$password = password(
- label: 'What is your password?',
- validate: fn (string $value) => match (true) {
- strlen($value) < 8 => 'The password must be at least 8 characters.',
- default => null
- }
-);
-```
-
-The closure will receive the value that has been entered and may return an error message, or `null` if the validation passes.
-
-Alternatively, you may leverage the power of Hypervel's [validator](/docs/validation). To do so, provide an array containing the name of the attribute and the desired validation rules to the `validate` argument:
-
-```php
-$password = password(
- label: 'What is your password?',
- validate: ['password' => 'min:8']
-);
-```
-
-### Confirm
-
-If you need to ask the user for a "yes or no" confirmation, you may use the `confirm` function. Users may use the arrow keys or press `y` or `n` to select their response. This function will return either `true` or `false`.
-
-```php
-use function Hypervel\Prompts\confirm;
-
-$confirmed = confirm('Do you accept the terms?');
-```
-
-You may also include a default value, customized wording for the "Yes" and "No" labels, and an informational hint:
-
-```php
-$confirmed = confirm(
- label: 'Do you accept the terms?',
- default: false,
- yes: 'I accept',
- no: 'I decline',
- hint: 'The terms must be accepted to continue.'
-);
-```
-
-#### Requiring "Yes"
-
-If necessary, you may require your users to select "Yes" by passing the `required` argument:
-
-```php
-$confirmed = confirm(
- label: 'Do you accept the terms?',
- required: true
-);
-```
-
-If you would like to customize the validation message, you may also pass a string:
-
-```php
-$confirmed = confirm(
- label: 'Do you accept the terms?',
- required: 'You must accept the terms to continue.'
-);
-```
-
-### Select
-
-If you need the user to select from a predefined set of choices, you may use the `select` function:
-
-```php
-use function Hypervel\Prompts\select;
-
-$role = select(
- label: 'What role should the user have?',
- options: ['Member', 'Contributor', 'Owner']
-);
-```
-
-You may also specify the default choice and an informational hint:
-
-```php
-$role = select(
- label: 'What role should the user have?',
- options: ['Member', 'Contributor', 'Owner'],
- default: 'Owner',
- hint: 'The role may be changed at any time.'
-);
-```
-
-You may also pass an associative array to the `options` argument to have the selected key returned instead of its value:
-
-```php
-$role = select(
- label: 'What role should the user have?',
- options: [
- 'member' => 'Member',
- 'contributor' => 'Contributor',
- 'owner' => 'Owner',
- ],
- default: 'owner'
-);
-```
-
-Up to five options will be displayed before the list begins to scroll. You may customize this by passing the `scroll` argument:
-
-```php
-$role = select(
- label: 'Which category would you like to assign?',
- options: Category::pluck('name', 'id'),
- scroll: 10
-);
-```
-
-#### Additional Validation
-
-Unlike other prompt functions, the `select` function doesn't accept the `required` argument because it is not possible to select nothing. However, you may pass a closure to the `validate` argument if you need to present an option but prevent it from being selected:
-
-```php
-$role = select(
- label: 'What role should the user have?',
- options: [
- 'member' => 'Member',
- 'contributor' => 'Contributor',
- 'owner' => 'Owner',
- ],
- validate: fn (string $value) =>
- $value === 'owner' && User::where('role', 'owner')->exists()
- ? 'An owner already exists.'
- : null
-);
-```
-
-If the `options` argument is an associative array, then the closure will receive the selected key, otherwise it will receive the selected value. The closure may return an error message, or `null` if the validation passes.
-
-### Multi-select
-
-If you need the user to be able to select multiple options, you may use the `multiselect` function:
-
-```php
-use function Hypervel\Prompts\multiselect;
-
-$permissions = multiselect(
- label: 'What permissions should be assigned?',
- options: ['Read', 'Create', 'Update', 'Delete']
-);
-```
-
-You may also specify default choices and an informational hint:
-
-```php
-use function Hypervel\Prompts\multiselect;
-
-$permissions = multiselect(
- label: 'What permissions should be assigned?',
- options: ['Read', 'Create', 'Update', 'Delete'],
- default: ['Read', 'Create'],
- hint: 'Permissions may be updated at any time.'
-);
-```
-
-You may also pass an associative array to the `options` argument to return the selected options' keys instead of their values:
-
-```php
-$permissions = multiselect(
- label: 'What permissions should be assigned?',
- options: [
- 'read' => 'Read',
- 'create' => 'Create',
- 'update' => 'Update',
- 'delete' => 'Delete',
- ],
- default: ['read', 'create']
-);
-```
-
-Up to five options will be displayed before the list begins to scroll. You may customize this by passing the `scroll` argument:
-
-```php
-$categories = multiselect(
- label: 'What categories should be assigned?',
- options: Category::pluck('name', 'id'),
- scroll: 10
-);
-```
-
-#### Requiring a Value
-
-By default, the user may select zero or more options. You may pass the `required` argument to enforce one or more options instead:
-
-```php
-$categories = multiselect(
- label: 'What categories should be assigned?',
- options: Category::pluck('name', 'id'),
- required: true
-);
-```
-
-If you would like to customize the validation message, you may provide a string to the `required` argument:
-
-```php
-$categories = multiselect(
- label: 'What categories should be assigned?',
- options: Category::pluck('name', 'id'),
- required: 'You must select at least one category'
-);
-```
-
-#### Additional Validation
-
-You may pass a closure to the `validate` argument if you need to present an option but prevent it from being selected:
-
-```php
-$permissions = multiselect(
- label: 'What permissions should the user have?',
- options: [
- 'read' => 'Read',
- 'create' => 'Create',
- 'update' => 'Update',
- 'delete' => 'Delete',
- ],
- validate: fn (array $values) => ! in_array('read', $values)
- ? 'All users require the read permission.'
- : null
-);
-```
-
-If the `options` argument is an associative array then the closure will receive the selected keys, otherwise it will receive the selected values. The closure may return an error message, or `null` if the validation passes.
-
-### Suggest
-
-The `suggest` function can be used to provide auto-completion for possible choices. The user can still provide any answer, regardless of the auto-completion hints:
-
-```php
-use function Hypervel\Prompts\suggest;
-
-$name = suggest('What is your name?', ['Taylor', 'Dayle']);
-```
-
-Alternatively, you may pass a closure as the second argument to the `suggest` function. The closure will be called each time the user types an input character. The closure should accept a string parameter containing the user's input so far and return an array of options for auto-completion:
-
-```php
-$name = suggest(
- label: 'What is your name?',
- options: fn ($value) => collect(['Taylor', 'Dayle'])
- ->filter(fn ($name) => Str::contains($name, $value, ignoreCase: true))
-)
-```
-
-You may also include placeholder text, a default value, and an informational hint:
-
-```php
-$name = suggest(
- label: 'What is your name?',
- options: ['Taylor', 'Dayle'],
- placeholder: 'E.g. Taylor',
- default: $user?->name,
- hint: 'This will be displayed on your profile.'
-);
-```
-
-#### Required Values
-
-If you require a value to be entered, you may pass the `required` argument:
-
-```php
-$name = suggest(
- label: 'What is your name?',
- options: ['Taylor', 'Dayle'],
- required: true
-);
-```
-
-If you would like to customize the validation message, you may also pass a string:
-
-```php
-$name = suggest(
- label: 'What is your name?',
- options: ['Taylor', 'Dayle'],
- required: 'Your name is required.'
-);
-```
-
-#### Additional Validation
-
-Finally, if you would like to perform additional validation logic, you may pass a closure to the `validate` argument:
-
-```php
-$name = suggest(
- label: 'What is your name?',
- options: ['Taylor', 'Dayle'],
- validate: fn (string $value) => match (true) {
- strlen($value) < 3 => 'The name must be at least 3 characters.',
- strlen($value) > 255 => 'The name must not exceed 255 characters.',
- default => null
- }
-);
-```
-
-The closure will receive the value that has been entered and may return an error message, or `null` if the validation passes.
-
-Alternatively, you may leverage the power of Hypervel's [validator](/docs/validation). To do so, provide an array containing the name of the attribute and the desired validation rules to the `validate` argument:
-
-```php
-$name = suggest(
- label: 'What is your name?',
- options: ['Taylor', 'Dayle'],
- validate: ['name' => 'required|min:3|max:255']
-);
-```
-
-### Search
-
-If you have a lot of options for the user to select from, the `search` function allows the user to type a search query to filter the results before using the arrow keys to select an option:
-
-```php
-use function Hypervel\Prompts\search;
-
-$id = search(
- label: 'Search for the user that should receive the mail',
- options: fn (string $value) => strlen($value) > 0
- ? User::whereLike('name', "%{$value}%")->pluck('name', 'id')->all()
- : []
-);
-```
-
-The closure will receive the text that has been typed by the user so far and must return an array of options. If you return an associative array then the selected option's key will be returned, otherwise its value will be returned instead.
-
-When filtering an array where you intend to return the value, you should use the `array_values` function or the `values` Collection method to ensure the array doesn't become associative:
-
-```php
-$names = collect(['Taylor', 'Abigail']);
-
-$selected = search(
- label: 'Search for the user that should receive the mail',
- options: fn (string $value) => $names
- ->filter(fn ($name) => Str::contains($name, $value, ignoreCase: true))
- ->values()
- ->all(),
-);
-```
-
-You may also include placeholder text and an informational hint:
-
-```php
-$id = search(
- label: 'Search for the user that should receive the mail',
- placeholder: 'E.g. Taylor Otwell',
- options: fn (string $value) => strlen($value) > 0
- ? User::whereLike('name', "%{$value}%")->pluck('name', 'id')->all()
- : [],
- hint: 'The user will receive an email immediately.'
-);
-```
-
-Up to five options will be displayed before the list begins to scroll. You may customize this by passing the `scroll` argument:
-
-```php
-$id = search(
- label: 'Search for the user that should receive the mail',
- options: fn (string $value) => strlen($value) > 0
- ? User::whereLike('name', "%{$value}%")->pluck('name', 'id')->all()
- : [],
- scroll: 10
-);
-```
-
-#### Additional Validation
-
-If you would like to perform additional validation logic, you may pass a closure to the `validate` argument:
-
-```php
-$id = search(
- label: 'Search for the user that should receive the mail',
- options: fn (string $value) => strlen($value) > 0
- ? User::whereLike('name', "%{$value}%")->pluck('name', 'id')->all()
- : [],
- validate: function (int|string $value) {
- $user = User::findOrFail($value);
-
- if ($user->opted_out) {
- return 'This user has opted-out of receiving mail.';
- }
- }
-);
-```
-
-If the `options` closure returns an associative array, then the closure will receive the selected key, otherwise, it will receive the selected value. The closure may return an error message, or `null` if the validation passes.
-
-### Multi-search
-
-If you have a lot of searchable options and need the user to be able to select multiple items, the `multisearch` function allows the user to type a search query to filter the results before using the arrow keys and space-bar to select options:
-
-```php
-use function Hypervel\Prompts\multisearch;
-
-$ids = multisearch(
- 'Search for the users that should receive the mail',
- fn (string $value) => strlen($value) > 0
- ? User::whereLike('name', "%{$value}%")->pluck('name', 'id')->all()
- : []
-);
-```
-
-The closure will receive the text that has been typed by the user so far and must return an array of options. If you return an associative array then the selected options' keys will be returned; otherwise, their values will be returned instead.
-
-When filtering an array where you intend to return the value, you should use the `array_values` function or the `values` Collection method to ensure the array doesn't become associative:
-
-```php
-$names = collect(['Taylor', 'Abigail']);
-
-$selected = multisearch(
- label: 'Search for the users that should receive the mail',
- options: fn (string $value) => $names
- ->filter(fn ($name) => Str::contains($name, $value, ignoreCase: true))
- ->values()
- ->all(),
-);
-```
-
-You may also include placeholder text and an informational hint:
-
-```php
-$ids = multisearch(
- label: 'Search for the users that should receive the mail',
- placeholder: 'E.g. Taylor Otwell',
- options: fn (string $value) => strlen($value) > 0
- ? User::whereLike('name', "%{$value}%")->pluck('name', 'id')->all()
- : [],
- hint: 'The user will receive an email immediately.'
-);
-```
-
-Up to five options will be displayed before the list begins to scroll. You may customize this by providing the `scroll` argument:
-
-```php
-$ids = multisearch(
- label: 'Search for the users that should receive the mail',
- options: fn (string $value) => strlen($value) > 0
- ? User::whereLike('name', "%{$value}%")->pluck('name', 'id')->all()
- : [],
- scroll: 10
-);
-```
-
-#### Requiring a Value
-
-By default, the user may select zero or more options. You may pass the `required` argument to enforce one or more options instead:
-
-```php
-$ids = multisearch(
- label: 'Search for the users that should receive the mail',
- options: fn (string $value) => strlen($value) > 0
- ? User::whereLike('name', "%{$value}%")->pluck('name', 'id')->all()
- : [],
- required: true
-);
-```
-
-If you would like to customize the validation message, you may also provide a string to the `required` argument:
-
-```php
-$ids = multisearch(
- label: 'Search for the users that should receive the mail',
- options: fn (string $value) => strlen($value) > 0
- ? User::whereLike('name', "%{$value}%")->pluck('name', 'id')->all()
- : [],
- required: 'You must select at least one user.'
-);
-```
-
-#### Additional Validation
-
-If you would like to perform additional validation logic, you may pass a closure to the `validate` argument:
-
-```php
-$ids = multisearch(
- label: 'Search for the users that should receive the mail',
- options: fn (string $value) => strlen($value) > 0
- ? User::whereLike('name', "%{$value}%")->pluck('name', 'id')->all()
- : [],
- validate: function (array $values) {
- $optedOut = User::whereLike('name', '%a%')->findMany($values);
-
- if ($optedOut->isNotEmpty()) {
- return $optedOut->pluck('name')->join(', ', ', and ').' have opted out.';
- }
- }
-);
-```
-
-If the `options` closure returns an associative array, then the closure will receive the selected keys; otherwise, it will receive the selected values. The closure may return an error message, or `null` if the validation passes.
-
-### Pause
-
-The `pause` function may be used to display informational text to the user and wait for them to confirm their desire to proceed by pressing the Enter / Return key:
-
-```php
-use function Hypervel\Prompts\pause;
-
-pause('Press ENTER to continue.');
-```
-
-## Transforming Input Before Validation
-
-Sometimes you may want to transform the prompt input before validation takes place. For example, you may wish to remove white space from any provided strings. To accomplish this, many of the prompt functions provide a `transform` argument, which accepts a closure:
-
-```php
-$name = text(
- label: 'What is your name?',
- transform: fn (string $value) => trim($value),
- validate: fn (string $value) => match (true) {
- strlen($value) < 3 => 'The name must be at least 3 characters.',
- strlen($value) > 255 => 'The name must not exceed 255 characters.',
- default => null
- }
-);
-```
-
-## Forms
-
-Often, you will have multiple prompts that will be displayed in sequence to collect information before performing additional actions. You may use the `form` function to create a grouped set of prompts for the user to complete:
-
-```php
-use function Hypervel\Prompts\form;
-
-$responses = form()
- ->text('What is your name?', required: true)
- ->password('What is your password?', validate: ['password' => 'min:8'])
- ->confirm('Do you accept the terms?')
- ->submit();
-```
-
-The `submit` method will return a numerically indexed array containing all of the responses from the form's prompts. However, you may provide a name for each prompt via the `name` argument. When a name is provided, the named prompt's response may be accessed via that name:
-
-```php
-use App\Models\User;
-use function Hypervel\Prompts\form;
-
-$responses = form()
- ->text('What is your name?', required: true, name: 'name')
- ->password(
- label: 'What is your password?',
- validate: ['password' => 'min:8'],
- name: 'password'
- )
- ->confirm('Do you accept the terms?')
- ->submit();
-
-User::create([
- 'name' => $responses['name'],
- 'password' => $responses['password'],
-]);
-```
-
-The primary benefit of using the `form` function is the ability for the user to return to previous prompts in the form using `CTRL + U`. This allows the user to fix mistakes or alter selections without needing to cancel and restart the entire form.
-
-If you need more granular control over a prompt in a form, you may invoke the `add` method instead of calling one of the prompt functions directly. The `add` method is passed all previous responses provided by the user:
-
-```php
-use function Hypervel\Prompts\form;
-use function Hypervel\Prompts\outro;
-use function Hypervel\Prompts\text;
-
-$responses = form()
- ->text('What is your name?', required: true, name: 'name')
- ->add(function ($responses) {
- return text("How old are you, {$responses['name']}?");
- }, name: 'age')
- ->submit();
-
-outro("Your name is {$responses['name']} and you are {$responses['age']} years old.");
-```
-
-## Informational Messages
-
-The `note`, `info`, `warning`, `error`, and `alert` functions may be used to display informational messages:
-
-```php
-use function Hypervel\Prompts\info;
-
-info('Package installed successfully.');
-```
-
-## Tables
-
-The `table` function makes it easy to display multiple rows and columns of data. All you need to do is provide the column names and the data for the table:
-
-```php
-use function Hypervel\Prompts\table;
-
-table(
- headers: ['Name', 'Email'],
- rows: User::all(['name', 'email'])->toArray()
-);
-```
-
-## Spin
-
-The `spin` function displays a spinner along with an optional message while executing a specified callback. It serves to indicate ongoing processes and returns the callback's results upon completion:
-
-```php
-use function Hypervel\Prompts\spin;
-
-$response = spin(
- callback: fn () => Http::get('http://example.com'),
- message: 'Fetching response...'
-);
-```
-
-## Progress Bars
-
-For long running tasks, it can be helpful to show a progress bar that informs users how complete the task is. Using the `progress` function, Hypervel will display a progress bar and advance its progress for each iteration over a given iterable value:
-
-```php
-use function Hypervel\Prompts\progress;
-
-$users = progress(
- label: 'Updating users',
- steps: User::all(),
- callback: fn ($user) => $this->performTask($user)
-);
-```
-
-The `progress` function acts like a map function and will return an array containing the return value of each iteration of your callback.
-
-The callback may also accept the `Hypervel\Prompts\Progress` instance, allowing you to modify the label and hint on each iteration:
-
-```php
-$users = progress(
- label: 'Updating users',
- steps: User::all(),
- callback: function ($user, $progress) {
- $progress
- ->label("Updating {$user->name}")
- ->hint("Created on {$user->created_at}");
-
- return $this->performTask($user);
- },
- hint: 'This may take some time.'
-);
-```
-
-Sometimes, you may need more manual control over how a progress bar is advanced. First, define the total number of steps the process will iterate through. Then, advance the progress bar via the `advance` method after processing each item:
-
-```php
-$progress = progress(label: 'Updating users', steps: 10);
-
-$users = User::all();
-
-$progress->start();
-
-foreach ($users as $user) {
- $this->performTask($user);
-
- $progress->advance();
-}
-
-$progress->finish();
-```
-
-## Clearing the Terminal
-
-The `clear` function may be used to clear the user's terminal:
-
-```php
-use function Hypervel\Prompts\clear;
-
-clear();
-```
-
-## Terminal Considerations
-
-#### Terminal Width
-
-If the length of any label, option, or validation message exceeds the number of "columns" in the user's terminal, it will be automatically truncated to fit. Consider minimizing the length of these strings if your users may be using narrower terminals. A typically safe maximum length is 74 characters to support an 80-character terminal.
-
-#### Terminal Height
-
-For any prompts that accept the `scroll` argument, the configured value will automatically be reduced to fit the height of the user's terminal, including space for a validation message.
-
-#### Fallback Conditions
-
-If you are not using Hypervel or need to customize when the fallback behavior is used, you may pass a boolean to the `fallbackWhen` static method on the `Prompt` class:
-
-```php
-use Hypervel\Prompts\Prompt;
-
-Prompt::fallbackWhen(
- ! $input->isInteractive() || windows_os() || app()->runningUnitTests()
-);
-```
-
-#### Fallback Behavior
-
-If you are not using Hypervel or need to customize the fallback behavior, you may pass a closure to the `fallbackUsing` static method on each prompt class:
-
-```php
-use Hypervel\Prompts\TextPrompt;
-use Symfony\Component\Console\Question\Question;
-use Symfony\Component\Console\Style\SymfonyStyle;
-
-TextPrompt::fallbackUsing(function (TextPrompt $prompt) use ($input, $output) {
- $question = (new Question($prompt->label, $prompt->default ?: null))
- ->setValidator(function ($answer) use ($prompt) {
- if ($prompt->required && $answer === null) {
- throw new \RuntimeException(
- is_string($prompt->required) ? $prompt->required : 'Required.'
- );
- }
-
- if ($prompt->validate) {
- $error = ($prompt->validate)($answer ?? '');
-
- if ($error) {
- throw new \RuntimeException($error);
- }
- }
-
- return $answer;
- });
-
- return (new SymfonyStyle($input, $output))
- ->askQuestion($question);
-});
-```
-
-Fallbacks must be configured individually for each prompt class. The closure will receive an instance of the prompt class and must return an appropriate type for the prompt.
-
-## Testing
-
-Hypervel provides a variety of methods for testing that your command displays the expected Prompt messages:
-
-```php
-public function testReportGeneration(): void
-{
- $this->artisan('report:generate')
- ->expectsPromptsInfo('Welcome to the application!')
- ->expectsPromptsWarning('This action cannot be undone')
- ->expectsPromptsError('Something went wrong')
- ->expectsPromptsAlert('Important notice!')
- ->expectsPromptsIntro('Starting process...')
- ->expectsPromptsOutro('Process completed!')
- ->expectsPrompexpectsPromptsWarningtsTable(
- headers: ['Name', 'Email'],
- rows: [
- ['Taylor Otwell', 'taylor@example.com'],
- ['Jason Beggs', 'jason@example.com'],
- ]
- )->assertExitCode(0);
-}
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/providers.md b/_archive/docs/0.3/docs/providers.md
deleted file mode 100644
index a4602238b6..0000000000
--- a/_archive/docs/0.3/docs/providers.md
+++ /dev/null
@@ -1,187 +0,0 @@
-# Service Providers
-[[toc]]
-
-## Introduction
-
-Service providers are the central place of all Hypervel application bootstrapping. Your own application, as well as all of Laravel's core services, are bootstrapped via service providers.
-
-Hypervel ensures that all components are properly configured and ready for use as soon as the application starts. This approach allows for a modular and flexible configuration system, where each component can manage its own configuration independently.
-
-But, what do we mean by "bootstrapped"? In general, we mean **registering** things, including registering service container bindings, event listeners, middleware, and even routes. Service providers are the central place to configure your application.
-
-If you open the `config/app.php` file included with Hypervel, you will see a providers array. These are all of the service provider classes that will be loaded for your application. By default, a set of Hypervel core service providers are listed in this array.
-
-In this overview, you will learn how to write your own service providers and register them with your Hypervel application.
-
-::: note
-If you would like to learn more about how Hypervel handles requests and works internally, check out our documentation on the Laravel [request lifecycle](/docs/lifecycle).
-:::
-
-## Writing Service Providers
-
-All service providers extend the `Hypervel\Support\ServiceProvider` class. Most service providers contain a `register` and a `boot` method. Within the `register` method, you should **only bind things into the [service container](/docs/container)**. You should never attempt to register any event listeners, routes, or any other piece of functionality within the `register` method.
-
-The Artisan CLI can generate a new provider via the `make:provider` command.
-
-```shell:no-line-numbers
-php artisan make:provider RiakServiceProvider
-```
-
-### The Register Method
-
-As mentioned previously, within the `register` method, you should only bind things into the [service container](/docs/container). You should never attempt to register any event listeners, routes, or any other piece of functionality within the `register` method. Otherwise, you may accidentally use a service that is provided by a service provider which has not loaded yet.
-
-Let's take a look at a basic service provider. Within any of your service provider methods, you always have access to the `$app` property which provides access to the service container:
-
-```php
-app->bind(Connection::class, function (Application $app) {
- return new Connection(config('riak'));
- });
- }
-}
-```
-
-This service provider only defines a `register` method, and uses that method to define an implementation of `App\Services\Riak\Connection` in the service container. If you're not yet familiar with Hypervel's service container, check out [its documentation](/docs/container).
-
-#### The `bindings` Properties
-
-If your service provider registers many simple bindings, you may wish to use the `bindings` property instead of manually registering each container binding. When the service provider is loaded by the framework, it will automatically check for these properties and register their bindings:
-
-```php
- DigitalOceanServerProvider::class,
- ];
-}
-```
-
-:::tip
-You can also set these bindings in `config/dependencies.php`.
-:::
-
-### The Boot Method
-
-So, what if we need to extend `Request` functions within our service provider? This should be done within the `boot` method. **This method is called after all other service providers have been registered**, meaning you have access to all other services that have been registered by the framework:
-
-```php
-setDefaultConnection('mysql');
-}
-```
-
-### Writing Provider Config
-
-Some behaviors must be achieved in config provider, such as class map replacement or aspect registration. Service providers can also provide the same functionality, you just need to implement `getProviderConfig` in the service provider:
-
-```php
-public static function getProviderConfig(): array
-{
- return [
- 'dependencies' => [],
- 'annotations' => [
- 'scan' => [
- 'paths' => [
- __DIR__,
- ],
- ],
- ],
- 'listeners' => [],
- 'publish' => [
- [
- 'id' => 'config',
- 'description' => 'description of this config file.',
- 'source' => __DIR__ . '/../publish/file.php',
- 'destination' => BASE_PATH . '/config/autoload/file.php',
- ],
- ],
- ];
-}
-```
-
-Then you need to configure your service provider in `composer.json` for auto discovery:
-
-```json
-"extra": {
- "branch-alias": {
- "dev-main": "0.3-dev"
- },
- "hypervel": {
- "providers": [
- "Hypervel\\Sanctum\\SanctumServiceProvider"
- ]
- }
-}
-```
-
-## Registering Providers
-
-All service providers are registered in the `config/app.php` configuration file. This file contains a `providers` array where you can list the class names of your service providers. By default, a set of Hypervel core service providers are registered in this array. The default providers bootstrap the core Hypervel components.
-
-To register your provider, add it to the array:
-
-```php
-'providers' => [
- Hypervel\Foundation\Providers\FoundationServiceProvider::class,
- App\Providers\RouteServiceProvider::class,
- App\Providers\AppServiceProvider::class,
- App\Providers\EventServiceProvider::class,
-]
-```
diff --git a/_archive/docs/0.3/docs/queries.md b/_archive/docs/0.3/docs/queries.md
deleted file mode 100644
index 50dff8072e..0000000000
--- a/_archive/docs/0.3/docs/queries.md
+++ /dev/null
@@ -1,1282 +0,0 @@
-# Database: Query Builder
-[[toc]]
-
-## Introduction
-
-Hypervel's database query builder provides a convenient, fluent interface to creating and running database queries. It can be used to perform most database operations in your application and works perfectly with all of Hypervel's supported database systems.
-
-The Hypervel query builder uses PDO parameter binding to protect your application against SQL injection attacks. There is no need to clean or sanitize strings passed to the query builder as query bindings.
-
-::: warning
-PDO does not support binding column names. Therefore, you should never allow user input to dictate the column names referenced by your queries, including "order by" columns.
-:::
-
-## Running Database Queries
-
-#### Retrieving All Rows From a Table
-
-You may use the `table` method provided by the `DB` facade to begin a query. The `table` method returns a fluent query builder instance for the given table, allowing you to chain more constraints onto the query and then finally retrieve the results of the query using the `get` method:
-
-```php
-get();
-
- return view('user.index', ['users' => $users]);
- }
-}
-```
-
-The `get` method returns an `Hypervel\Support\Collection` instance containing the results of the query where each result is an instance of the PHP `stdClass` object. You may access each column's value by accessing the column as a property of the object:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-$users = DB::table('users')->get();
-
-foreach ($users as $user) {
- echo $user->name;
-}
-```
-
-::: note
-Hypervel collections provide a variety of extremely powerful methods for mapping and reducing data. For more information on Hypervel collections, check out the [collection documentation](/docs/collections).
-:::
-
-#### Retrieving a Single Row / Column From a Table
-
-If you just need to retrieve a single row from a database table, you may use the `DB` facade's `first` method. This method will return a single `stdClass` object:
-
-```php
-$user = DB::table('users')->where('name', 'John')->first();
-
-return $user->email;
-```
-
-If you would like to retrieve a single row from a database table, but throw an `Hyperf\Database\Model\ModelNotFoundException` if no matching row is found, you may use the `firstOrFail` method. If the `ModelNotFoundException` is not caught, a 404 HTTP response is automatically sent back to the client:
-
-```php
-$user = DB::table('users')->where('name', 'John')->firstOrFail();
-```
-
-If you don't need an entire row, you may extract a single value from a record using the `value` method. This method will return the value of the column directly:
-
-```php
-$email = DB::table('users')->where('name', 'John')->value('email');
-```
-
-To retrieve a single row by its `id` column value, use the `find` method:
-
-```php
-$user = DB::table('users')->find(3);
-```
-
-#### Retrieving a List of Column Values
-
-If you would like to retrieve an `Hypervel\Support\Collection` instance containing the values of a single column, you may use the `pluck` method. In this example, we'll retrieve a collection of user titles:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-$titles = DB::table('users')->pluck('title');
-
-foreach ($titles as $title) {
- echo $title;
-}
-```
-
-You may specify the column that the resulting collection should use as its keys by providing a second argument to the `pluck` method:
-
-```php
-$titles = DB::table('users')->pluck('title', 'name');
-
-foreach ($titles as $name => $title) {
- echo $title;
-}
-```
-
-### Chunking Results
-
-If you need to work with thousands of database records, consider using the `chunk` method provided by the `DB` facade. This method retrieves a small chunk of results at a time and feeds each chunk into a closure for processing. For example, let's retrieve the entire `users` table in chunks of 100 records at a time:
-
-```php
-use Hypervel\Support\Collection;
-use Hypervel\Support\Facades\DB;
-
-DB::table('users')->orderBy('id')->chunk(100, function (Collection $users) {
- foreach ($users as $user) {
- // ...
- }
-});
-```
-
-You may stop further chunks from being processed by returning `false` from the closure:
-
-```php
-DB::table('users')->orderBy('id')->chunk(100, function (Collection $users) {
- // Process the records...
-
- return false;
-});
-```
-
-If you are updating database records while chunking results, your chunk results could change in unexpected ways. If you plan to update the retrieved records while chunking, it is always best to use the `chunkById` method instead. This method will automatically paginate the results based on the record's primary key:
-
-```php
-DB::table('users')->where('active', false)
- ->chunkById(100, function (Collection $users) {
- foreach ($users as $user) {
- DB::table('users')
- ->where('id', $user->id)
- ->update(['active' => true]);
- }
- });
-```
-
-Since the `chunkById` and `lazyById` methods add their own "where" conditions to the query being executed, you should typically [logically group](#logical-grouping) your own conditions within a closure:
-
-```php
-DB::table('users')->where(function ($query) {
- $query->where('credits', 1)->orWhere('credits', 2);
-})->chunkById(100, function (Collection $users) {
- foreach ($users as $user) {
- DB::table('users')
- ->where('id', $user->id)
- ->update(['credits' => 3]);
- }
-});
-```
-
-::: warning
-When updating or deleting records inside the chunk callback, any changes to the primary key or foreign keys could affect the chunk query. This could potentially result in records not being included in the chunked results.
-:::
-
-### Streaming Results Lazily
-
-The `lazy` method works similarly to [the `chunk` method](#chunking-results) in the sense that it executes the query in chunks. However, instead of passing each chunk into a callback, the `lazy()` method returns a [`LazyCollection`](/docs/collections#lazy-collections), which lets you interact with the results as a single stream:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-DB::table('users')->orderBy('id')->lazy()->each(function (object $user) {
- // ...
-});
-```
-
-Once again, if you plan to update the retrieved records while iterating over them, it is best to use the `lazyById` or `lazyByIdDesc` methods instead. These methods will automatically paginate the results based on the record's primary key:
-
-```php
-DB::table('users')->where('active', false)
- ->lazyById()->each(function (object $user) {
- DB::table('users')
- ->where('id', $user->id)
- ->update(['active' => true]);
- });
-```
-
-::: warning
-When updating or deleting records while iterating over them, any changes to the primary key or foreign keys could affect the chunk query. This could potentially result in records not being included in the results.
-:::
-
-### Aggregates
-
-The query builder also provides a variety of methods for retrieving aggregate values like `count`, `max`, `min`, `avg`, and `sum`. You may call any of these methods after constructing your query:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-$users = DB::table('users')->count();
-
-$price = DB::table('orders')->max('price');
-```
-
-Of course, you may combine these methods with other clauses to fine-tune how your aggregate value is calculated:
-
-```php
-$price = DB::table('orders')
- ->where('finalized', 1)
- ->avg('price');
-```
-
-#### Determining if Records Exist
-
-Instead of using the `count` method to determine if any records exist that match your query's constraints, you may use the `exists` and `doesntExist` methods:
-
-```php
-if (DB::table('orders')->where('finalized', 1)->exists()) {
- // ...
-}
-
-if (DB::table('orders')->where('finalized', 1)->doesntExist()) {
- // ...
-}
-```
-
-## Select Statements
-
-#### Specifying a Select Clause
-
-You may not always want to select all columns from a database table. Using the `select` method, you can specify a custom "select" clause for the query:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-$users = DB::table('users')
- ->select('name', 'email as user_email')
- ->get();
-```
-
-The `distinct` method allows you to force the query to return distinct results:
-
-```php
-$users = DB::table('users')->distinct()->get();
-```
-
-If you already have a query builder instance and you wish to add a column to its existing select clause, you may use the `addSelect` method:
-
-```php
-$query = DB::table('users')->select('name');
-
-$users = $query->addSelect('age')->get();
-```
-
-## Raw Expressions
-
-Sometimes you may need to insert an arbitrary string into a query. To create a raw string expression, you may use the `raw` method provided by the `DB` facade:
-
-```php
-$users = DB::table('users')
- ->select(DB::raw('count(*) as user_count, status'))
- ->where('status', '<>', 1)
- ->groupBy('status')
- ->get();
-```
-
-::: warning
-Raw statements will be injected into the query as strings, so you should be extremely careful to avoid creating SQL injection vulnerabilities.
-:::
-
-### Raw Methods
-
-Instead of using the `DB::raw` method, you may also use the following methods to insert a raw expression into various parts of your query. **Remember, Hypervel cannot guarantee that any query using raw expressions is protected against SQL injection vulnerabilities.**
-
-#### `selectRaw`
-
-The `selectRaw` method can be used in place of `addSelect(DB::raw(/* ... */))`. This method accepts an optional array of bindings as its second argument:
-
-```php
-$orders = DB::table('orders')
- ->selectRaw('price * ? as price_with_tax', [1.0825])
- ->get();
-```
-
-#### `whereRaw / orWhereRaw`
-
-The `whereRaw` and `orWhereRaw` methods can be used to inject a raw "where" clause into your query. These methods accept an optional array of bindings as their second argument:
-
-```php
-$orders = DB::table('orders')
- ->whereRaw('price > IF(state = "TX", ?, 100)', [200])
- ->get();
-```
-
-#### `havingRaw / orHavingRaw`
-
-The `havingRaw` and `orHavingRaw` methods may be used to provide a raw string as the value of the "having" clause. These methods accept an optional array of bindings as their second argument:
-
-```php
-$orders = DB::table('orders')
- ->select('department', DB::raw('SUM(price) as total_sales'))
- ->groupBy('department')
- ->havingRaw('SUM(price) > ?', [2500])
- ->get();
-```
-
-#### `orderByRaw`
-
-The `orderByRaw` method may be used to provide a raw string as the value of the "order by" clause:
-
-```php
-$orders = DB::table('orders')
- ->orderByRaw('updated_at - created_at DESC')
- ->get();
-```
-
-### `groupByRaw`
-
-The `groupByRaw` method may be used to provide a raw string as the value of the `group by` clause:
-
-```php
-$orders = DB::table('orders')
- ->select('city', 'state')
- ->groupByRaw('city, state')
- ->get();
-```
-
-## Joins
-
-#### Inner Join Clause
-
-The query builder may also be used to add join clauses to your queries. To perform a basic "inner join", you may use the `join` method on a query builder instance. The first argument passed to the `join` method is the name of the table you need to join to, while the remaining arguments specify the column constraints for the join. You may even join multiple tables in a single query:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-$users = DB::table('users')
- ->join('contacts', 'users.id', '=', 'contacts.user_id')
- ->join('orders', 'users.id', '=', 'orders.user_id')
- ->select('users.*', 'contacts.phone', 'orders.price')
- ->get();
-```
-
-#### Left Join / Right Join Clause
-
-If you would like to perform a "left join" or "right join" instead of an "inner join", use the `leftJoin` or `rightJoin` methods. These methods have the same signature as the `join` method:
-
-```php
-$users = DB::table('users')
- ->leftJoin('posts', 'users.id', '=', 'posts.user_id')
- ->get();
-
-$users = DB::table('users')
- ->rightJoin('posts', 'users.id', '=', 'posts.user_id')
- ->get();
-```
-
-#### Cross Join Clause
-
-You may use the `crossJoin` method to perform a "cross join". Cross joins generate a cartesian product between the first table and the joined table:
-
-```php
-$sizes = DB::table('sizes')
- ->crossJoin('colors')
- ->get();
-```
-
-#### Advanced Join Clauses
-
-You may also specify more advanced join clauses. To get started, pass a closure as the second argument to the `join` method. The closure will receive a `Hyperf\Database\Query\JoinClause` instance which allows you to specify constraints on the "join" clause:
-
-```php
-DB::table('users')
- ->join('contacts', function (JoinClause $join) {
- $join->on('users.id', '=', 'contacts.user_id')->orOn(/* ... */);
- })
- ->get();
-```
-
-If you would like to use a "where" clause on your joins, you may use the `where` and `orWhere` methods provided by the `JoinClause` instance. Instead of comparing two columns, these methods will compare the column against a value:
-
-```php
-DB::table('users')
- ->join('contacts', function (JoinClause $join) {
- $join->on('users.id', '=', 'contacts.user_id')
- ->where('contacts.user_id', '>', 5);
- })
- ->get();
-```
-
-#### Subquery Joins
-
-You may use the `joinSub`, `leftJoinSub`, and `rightJoinSub` methods to join a query to a subquery. Each of these methods receives three arguments: the subquery, its table alias, and a closure that defines the related columns. In this example, we will retrieve a collection of users where each user record also contains the `created_at` timestamp of the user's most recently published blog post:
-
-```php
-$latestPosts = DB::table('posts')
- ->select('user_id', DB::raw('MAX(created_at) as last_post_created_at'))
- ->where('is_published', true)
- ->groupBy('user_id');
-
-$users = DB::table('users')
- ->joinSub($latestPosts, 'latest_posts', function (JoinClause $join) {
- $join->on('users.id', '=', 'latest_posts.user_id');
- })->get();
-```
-
-#### Lateral Joins
-
-::: warning
-Lateral joins are currently supported by PostgreSQL, MySQL >= 8.0.14, and SQL Server.
-:::
-
-You may use the `joinLateral` and `leftJoinLateral` methods to perform a "lateral join" with a subquery. Each of these methods receives two arguments: the subquery and its table alias. The join condition(s) should be specified within the `where` clause of the given subquery. Lateral joins are evaluated for each row and can reference columns outside the subquery.
-
-In this example, we will retrieve a collection of users as well as the user's three most recent blog posts. Each user can produce up to three rows in the result set: one for each of their most recent blog posts. The join condition is specified with a `whereColumn` clause within the subquery, referencing the current user row:
-
-```php
-$latestPosts = DB::table('posts')
- ->select('id as post_id', 'title as post_title', 'created_at as post_created_at')
- ->whereColumn('user_id', 'users.id')
- ->orderBy('created_at', 'desc')
- ->limit(3);
-
-$users = DB::table('users')
- ->joinLateral($latestPosts, 'latest_posts')
- ->get();
-```
-
-## Unions
-
-The query builder also provides a convenient method to "union" two or more queries together. For example, you may create an initial query and use the `union` method to union it with more queries:
-
-```php
-use Hypervel\Support\Facades\DB;
-
-$first = DB::table('users')
- ->whereNull('first_name');
-
-$users = DB::table('users')
- ->whereNull('last_name')
- ->union($first)
- ->get();
-```
-
-In addition to the `union` method, the query builder provides a `unionAll` method. Queries that are combined using the `unionAll` method will not have their duplicate results removed. The `unionAll` method has the same method signature as the `union` method.
-
-## Basic Where Clauses
-
-### Where Clauses
-
-You may use the query builder's `where` method to add "where" clauses to the query. The most basic call to the `where` method requires three arguments. The first argument is the name of the column. The second argument is an operator, which can be any of the database's supported operators. The third argument is the value to compare against the column's value.
-
-For example, the following query retrieves users where the value of the `votes` column is equal to `100` and the value of the `age` column is greater than `35`:
-
-```php
-$users = DB::table('users')
- ->where('votes', '=', 100)
- ->where('age', '>', 35)
- ->get();
-```
-
-For convenience, if you want to verify that a column is `=` to a given value, you may pass the value as the second argument to the `where` method. Hypervel will assume you would like to use the `=` operator:
-
-```php
-$users = DB::table('users')->where('votes', 100)->get();
-```
-
-As previously mentioned, you may use any operator that is supported by your database system:
-
-```php
-$users = DB::table('users')
- ->where('votes', '>=', 100)
- ->get();
-
-$users = DB::table('users')
- ->where('votes', '<>', 100)
- ->get();
-
-$users = DB::table('users')
- ->where('name', 'like', 'T%')
- ->get();
-```
-
-You may also pass an array of conditions to the `where` function. Each element of the array should be an array containing the three arguments typically passed to the `where` method:
-
-```php
-$users = DB::table('users')->where([
- ['status', '=', '1'],
- ['subscribed', '<>', '1'],
-])->get();
-```
-
-::: warning
-PDO does not support binding column names. Therefore, you should never allow user input to dictate the column names referenced by your queries, including "order by" columns.
-:::
-
-::: warning
-MySQL and MariaDB automatically typecast strings to integers in string-number comparisons. In this process, non-numeric strings are converted to `0`, which can lead to unexpected results. For example, if your table has a `secret` column with a value of `aaa` and you run `User::where('secret', 0)`, that row will be returned. To avoid this, ensure all values are typecast to their appropriate types before using them in queries.
-:::
-
-### Or Where Clauses
-
-When chaining together calls to the query builder's `where` method, the "where" clauses will be joined together using the `and` operator. However, you may use the `orWhere` method to join a clause to the query using the `or` operator. The `orWhere` method accepts the same arguments as the `where` method:
-
-```php
-$users = DB::table('users')
- ->where('votes', '>', 100)
- ->orWhere('name', 'John')
- ->get();
-```
-
-If you need to group an "or" condition within parentheses, you may pass a closure as the first argument to the `orWhere` method:
-
-```php
-$users = DB::table('users')
- ->where('votes', '>', 100)
- ->orWhere(function (Builder $query) {
- $query->where('name', 'Abigail')
- ->where('votes', '>', 50);
- })
- ->get();
-```
-
-The example above will produce the following SQL:
-
-```sql
-select * from users where votes > 100 or (name = 'Abigail' and votes > 50)
-```
-
-::: warning
-You should always group `orWhere` calls in order to avoid unexpected behavior when global scopes are applied.
-:::
-
-### Where Not Clauses
-
-The `whereNot` and `orWhereNot` methods may be used to negate a given group of query constraints. For example, the following query excludes products that are on clearance or which have a price that is less than ten:
-
-```php
-$products = DB::table('products')
- ->whereNot(function (Builder $query) {
- $query->where('clearance', true)
- ->orWhere('price', '<', 10);
- })
- ->get();
-```
-
-### Where Any / All / None Clauses
-
-Sometimes you may need to apply the same query constraints to multiple columns. For example, you may want to retrieve all records where any columns in a given list are `LIKE` a given value. You may accomplish this using the `whereAny` method:
-
-```php
-$users = DB::table('users')
- ->where('active', true)
- ->whereAny([
- 'name',
- 'email',
- 'phone',
- ], 'like', 'Example%')
- ->get();
-```
-
-The query above will result in the following SQL:
-
-```sql
-SELECT *
-FROM users
-WHERE active = true AND (
- name LIKE 'Example%' OR
- email LIKE 'Example%' OR
- phone LIKE 'Example%'
-)
-```
-
-Similarly, the `whereAll` method may be used to retrieve records where all of the given columns match a given constraint:
-
-```php
-$posts = DB::table('posts')
- ->where('published', true)
- ->whereAll([
- 'title',
- 'content',
- ], 'like', '%Laravel%')
- ->get();
-```
-
-The query above will result in the following SQL:
-
-```sql
-SELECT *
-FROM posts
-WHERE published = true AND (
- title LIKE '%Laravel%' AND
- content LIKE '%Laravel%'
-)
-```
-
-The `whereNone` method may be used to retrieve records where none of the given columns match a given constraint:
-
-```php
-$posts = DB::table('albums')
- ->where('published', true)
- ->whereNone([
- 'title',
- 'lyrics',
- 'tags',
- ], 'like', '%explicit%')
- ->get();
-```
-
-The query above will result in the following SQL:
-
-```sql
-SELECT *
-FROM albums
-WHERE published = true AND NOT (
- title LIKE '%explicit%' OR
- lyrics LIKE '%explicit%' OR
- tags LIKE '%explicit%'
-)
-```
-
-### JSON Where Clauses
-
-Hypervel also supports querying JSON column types on databases that provide support for JSON column types. Currently, this includes MariaDB 10.3+, MySQL 8.0+, PostgreSQL 12.0+, SQL Server 2017+, and SQLite 3.39.0+. To query a JSON column, use the `->` operator:
-
-```php
-$users = DB::table('users')
- ->where('preferences->dining->meal', 'salad')
- ->get();
-```
-
-You may use `whereJsonContains` to query JSON arrays:
-
-```php
-$users = DB::table('users')
- ->whereJsonContains('options->languages', 'en')
- ->get();
-```
-
-If your application uses the MariaDB, MySQL, or PostgreSQL databases, you may pass an array of values to the `whereJsonContains` method:
-
-```php
-$users = DB::table('users')
- ->whereJsonContains('options->languages', ['en', 'de'])
- ->get();
-```
-
-You may use `whereJsonLength` method to query JSON arrays by their length:
-
-```php
-$users = DB::table('users')
- ->whereJsonLength('options->languages', 0)
- ->get();
-
-$users = DB::table('users')
- ->whereJsonLength('options->languages', '>', 1)
- ->get();
-```
-
-### Additional Where Clauses
-
-**whereIn / whereNotIn / orWhereIn / orWhereNotIn**
-
-The `whereIn` method verifies that a given column's value is contained within the given array:
-
-```php
-$users = DB::table('users')
- ->whereIn('id', [1, 2, 3])
- ->get();
-```
-
-The `whereNotIn` method verifies that the given column's value is not contained in the given array:
-
-```php
-$users = DB::table('users')
- ->whereNotIn('id', [1, 2, 3])
- ->get();
-```
-
-You may also provide a query object as the `whereIn` method's second argument:
-
-```php
-$activeUsers = DB::table('users')->select('id')->where('is_active', 1);
-
-$users = DB::table('comments')
- ->whereIn('user_id', $activeUsers)
- ->get();
-```
-
-The example above will produce the following SQL:
-
-```sql
-select * from comments where user_id in (
- select id
- from users
- where is_active = 1
-)
-```
-
-::: warning
-If you are adding a large array of integer bindings to your query, the `whereIntegerInRaw` or `whereIntegerNotInRaw` methods may be used to greatly reduce your memory usage.
-:::
-
-**whereBetween / orWhereBetween**
-
-The `whereBetween` method verifies that a column's value is between two values:
-
-```php
-$users = DB::table('users')
- ->whereBetween('votes', [1, 100])
- ->get();
-```
-
-**whereNotBetween / orWhereNotBetween**
-
-The `whereNotBetween` method verifies that a column's value lies outside of two values:
-
-```php
-$users = DB::table('users')
- ->whereNotBetween('votes', [1, 100])
- ->get();
-```
-
-**whereNull / whereNotNull / orWhereNull / orWhereNotNull**
-
-The `whereNull` method verifies that the value of the given column is `NULL`:
-
-```php
-$users = DB::table('users')
- ->whereNull('updated_at')
- ->get();
-```
-
-The `whereNotNull` method verifies that the column's value is not `NULL`:
-
-```php
-$users = DB::table('users')
- ->whereNotNull('updated_at')
- ->get();
-```
-
-**whereDate / whereMonth / whereDay / whereYear / whereTime**
-
-The `whereDate` method may be used to compare a column's value against a date:
-
-```php
-$users = DB::table('users')
- ->whereDate('created_at', '2016-12-31')
- ->get();
-```
-
-The `whereMonth` method may be used to compare a column's value against a specific month:
-
-```php
-$users = DB::table('users')
- ->whereMonth('created_at', '12')
- ->get();
-```
-
-The `whereDay` method may be used to compare a column's value against a specific day of the month:
-
-```php
-$users = DB::table('users')
- ->whereDay('created_at', '31')
- ->get();
-```
-
-The `whereYear` method may be used to compare a column's value against a specific year:
-
-```php
-$users = DB::table('users')
- ->whereYear('created_at', '2016')
- ->get();
-```
-
-The `whereTime` method may be used to compare a column's value against a specific time:
-
-```php
-$users = DB::table('users')
- ->whereTime('created_at', '=', '11:20:45')
- ->get();
-```
-
-**whereColumn / orWhereColumn**
-
-The `whereColumn` method may be used to verify that two columns are equal:
-
-```php
-$users = DB::table('users')
- ->whereColumn('first_name', 'last_name')
- ->get();
-```
-
-You may also pass a comparison operator to the `whereColumn` method:
-
-```php
-$users = DB::table('users')
- ->whereColumn('updated_at', '>', 'created_at')
- ->get();
-```
-
-You may also pass an array of column comparisons to the `whereColumn` method. These conditions will be joined using the `and` operator:
-
-```php
-$users = DB::table('users')
- ->whereColumn([
- ['first_name', '=', 'last_name'],
- ['updated_at', '>', 'created_at'],
- ])->get();
-```
-
-### Logical Grouping
-
-Sometimes you may need to group several "where" clauses within parentheses in order to achieve your query's desired logical grouping. In fact, you should generally always group calls to the `orWhere` method in parentheses in order to avoid unexpected query behavior. To accomplish this, you may pass a closure to the `where` method:
-
-```php
-$users = DB::table('users')
- ->where('name', '=', 'John')
- ->where(function (Builder $query) {
- $query->where('votes', '>', 100)
- ->orWhere('title', '=', 'Admin');
- })
- ->get();
-```
-
-As you can see, passing a closure into the `where` method instructs the query builder to begin a constraint group. The closure will receive a query builder instance which you can use to set the constraints that should be contained within the parenthesis group. The example above will produce the following SQL:
-
-```sql
-select * from users where name = 'John' and (votes > 100 or title = 'Admin')
-```
-
-::: warning
-You should always group `orWhere` calls in order to avoid unexpected behavior when global scopes are applied.
-:::
-
-## Advanced Where Clauses
-
-### Where Exists Clauses
-
-The `whereExists` method allows you to write "where exists" SQL clauses. The `whereExists` method accepts a closure which will receive a query builder instance, allowing you to define the query that should be placed inside of the "exists" clause:
-
-```php
-$users = DB::table('users')
- ->whereExists(function (Builder $query) {
- $query->select(DB::raw(1))
- ->from('orders')
- ->whereColumn('orders.user_id', 'users.id');
- })
- ->get();
-```
-
-Alternatively, you may provide a query object to the `whereExists` method instead of a closure:
-
-```php
-$orders = DB::table('orders')
- ->select(DB::raw(1))
- ->whereColumn('orders.user_id', 'users.id');
-
-$users = DB::table('users')
- ->whereExists($orders)
- ->get();
-```
-
-Both of the examples above will produce the following SQL:
-
-```sql
-select * from users
-where exists (
- select 1
- from orders
- where orders.user_id = users.id
-)
-```
-
-### Subquery Where Clauses
-
-Sometimes you may need to construct a "where" clause that compares the results of a subquery to a given value. You may accomplish this by passing a closure and a value to the `where` method. For example, the following query will retrieve all users who have a recent "membership" of a given type;
-
-```php
-use App\Models\User;
-use Hyperf\Database\Query\Builder;
-
-$users = User::where(function (Builder $query) {
- $query->select('type')
- ->from('membership')
- ->whereColumn('membership.user_id', 'users.id')
- ->orderByDesc('membership.start_date')
- ->limit(1);
-}, 'Pro')->get();
-```
-
-Or, you may need to construct a "where" clause that compares a column to the results of a subquery. You may accomplish this by passing a column, operator, and closure to the `where` method. For example, the following query will retrieve all income records where the amount is less than average;
-
-```php
-use App\Models\Income;
-use Hyperf\Database\Query\Builder;
-
-$incomes = Income::where('amount', '<', function (Builder $query) {
- $query->selectRaw('avg(i.amount)')->from('incomes as i');
-})->get();
-```
-
-### Full Text Where Clauses
-
-::: warning
-Full text where clauses are currently supported by MariaDB, MySQL, and PostgreSQL.
-:::
-
-The `whereFullText` and `orWhereFullText` methods may be used to add full text "where" clauses to a query for columns that have [full text indexes](/docs/migrations#available-index-types). These methods will be transformed into the appropriate SQL for the underlying database system by Laravel. For example, a `MATCH AGAINST` clause will be generated for applications utilizing MariaDB or MySQL:
-
-```php
-$users = DB::table('users')
- ->whereFullText('bio', 'web developer')
- ->get();
-```
-
-## Ordering, Grouping, Limit and Offset
-
-### Ordering
-
-#### The `orderBy` Method
-
-The `orderBy` method allows you to sort the results of the query by a given column. The first argument accepted by the `orderBy` method should be the column you wish to sort by, while the second argument determines the direction of the sort and may be either `asc` or `desc`:
-
-```php
-$users = DB::table('users')
- ->orderBy('name', 'desc')
- ->get();
-```
-
-To sort by multiple columns, you may simply invoke `orderBy` as many times as necessary:
-
-```php
-$users = DB::table('users')
- ->orderBy('name', 'desc')
- ->orderBy('email', 'asc')
- ->get();
-```
-
-#### The `latest` and `oldest` Methods
-
-The `latest` and `oldest` methods allow you to easily order results by date. By default, the result will be ordered by the table's `created_at` column. Or, you may pass the column name that you wish to sort by:
-
-```php
-$user = DB::table('users')
- ->latest()
- ->first();
-```
-
-#### Random Ordering
-
-The `inRandomOrder` method may be used to sort the query results randomly. For example, you may use this method to fetch a random user:
-
-```php
-$randomUser = DB::table('users')
- ->inRandomOrder()
- ->first();
-```
-
-#### Removing Existing Orderings
-
-The `reorder` method removes all of the "order by" clauses that have previously been applied to the query:
-
-```php
-$query = DB::table('users')->orderBy('name');
-
-$unorderedUsers = $query->reorder()->get();
-```
-
-You may pass a column and direction when calling the `reorder` method in order to remove all existing "order by" clauses and apply an entirely new order to the query:
-
-```php
-$query = DB::table('users')->orderBy('name');
-
-$usersOrderedByEmail = $query->reorder('email', 'desc')->get();
-```
-
-### Grouping
-
-#### The `groupBy` and `having` Methods
-
-As you might expect, the `groupBy` and `having` methods may be used to group the query results. The `having` method's signature is similar to that of the `where` method:
-
-```php
-$users = DB::table('users')
- ->groupBy('account_id')
- ->having('account_id', '>', 100)
- ->get();
-```
-
-You can use the `havingBetween` method to filter the results within a given range:
-
-```php
-$report = DB::table('orders')
- ->selectRaw('count(id) as number_of_orders, customer_id')
- ->groupBy('customer_id')
- ->havingBetween('number_of_orders', [5, 15])
- ->get();
-```
-
-You may pass multiple arguments to the `groupBy` method to group by multiple columns:
-
-```php
-$users = DB::table('users')
- ->groupBy('first_name', 'status')
- ->having('account_id', '>', 100)
- ->get();
-```
-
-To build more advanced `having` statements, see the [`havingRaw`](#raw-methods) method.
-
-### Limit and Offset
-
-#### The `skip` and `take` Methods
-
-You may use the `skip` and `take` methods to limit the number of results returned from the query or to skip a given number of results in the query:
-
-```php
-$users = DB::table('users')->skip(10)->take(5)->get();
-```
-
-Alternatively, you may use the `limit` and `offset` methods. These methods are functionally equivalent to the `take` and `skip` methods, respectively:
-
-```php
-$users = DB::table('users')
- ->offset(10)
- ->limit(5)
- ->get();
-```
-
-## Conditional Clauses
-
-Sometimes you may want certain query clauses to apply to a query based on another condition. For instance, you may only want to apply a `where` statement if a given input value is present on the incoming HTTP request. You may accomplish this using the `when` method:
-
-```php
-$role = $request->input('role');
-
-$users = DB::table('users')
- ->when($role, function (Builder $query, string $role) {
- $query->where('role_id', $role);
- })
- ->get();
-```
-
-The `when` method only executes the given closure when the first argument is `true`. If the first argument is `false`, the closure will not be executed. So, in the example above, the closure given to the `when` method will only be invoked if the `role` field is present on the incoming request and evaluates to `true`.
-
-You may pass another closure as the third argument to the `when` method. This closure will only execute if the first argument evaluates as `false`. To illustrate how this feature may be used, we will use it to configure the default ordering of a query:
-
-```php
-$sortByVotes = $request->boolean('sort_by_votes');
-
-$users = DB::table('users')
- ->when($sortByVotes, function (Builder $query, bool $sortByVotes) {
- $query->orderBy('votes');
- }, function (Builder $query) {
- $query->orderBy('name');
- })
- ->get();
-```
-
-## Insert Statements
-
-The query builder also provides an `insert` method that may be used to insert records into the database table. The `insert` method accepts an array of column names and values:
-
-```php
-DB::table('users')->insert([
- 'email' => 'kayla@example.com',
- 'votes' => 0
-]);
-```
-
-You may insert several records at once by passing an array of arrays. Each array represents a record that should be inserted into the table:
-
-```php
-DB::table('users')->insert([
- ['email' => 'picard@example.com', 'votes' => 0],
- ['email' => 'janeway@example.com', 'votes' => 0],
-]);
-```
-
-The `insertOrIgnore` method will ignore errors while inserting records into the database. When using this method, you should be aware that duplicate record errors will be ignored and other types of errors may also be ignored depending on the database engine. For example, `insertOrIgnore` will [bypass MySQL's strict mode](https://dev.mysql.com/doc/refman/en/sql-mode.html#ignore-effect-on-execution):
-
-```php
-DB::table('users')->insertOrIgnore([
- ['id' => 1, 'email' => 'sisko@example.com'],
- ['id' => 2, 'email' => 'archer@example.com'],
-]);
-```
-
-The `insertUsing` method will insert new records into the table while using a subquery to determine the data that should be inserted:
-
-```php
-DB::table('pruned_users')->insertUsing([
- 'id', 'name', 'email', 'email_verified_at'
-], DB::table('users')->select(
- 'id', 'name', 'email', 'email_verified_at'
-)->where('updated_at', '<=', now()->subMonth()));
-```
-
-#### Auto-Incrementing IDs
-
-If the table has an auto-incrementing id, use the `insertGetId` method to insert a record and then retrieve the ID:
-
-```php
-$id = DB::table('users')->insertGetId(
- ['email' => 'john@example.com', 'votes' => 0]
-);
-```
-
-::: warning
-When using PostgreSQL the `insertGetId` method expects the auto-incrementing column to be named `id`. If you would like to retrieve the ID from a different "sequence", you may pass the column name as the second parameter to the `insertGetId` method.
-:::
-
-### Upserts
-
-The `upsert` method will insert records that do not exist and update the records that already exist with new values that you may specify. The method's first argument consists of the values to insert or update, while the second argument lists the column(s) that uniquely identify records within the associated table. The method's third and final argument is an array of columns that should be updated if a matching record already exists in the database:
-
-```php
-DB::table('flights')->upsert(
- [
- ['departure' => 'Oakland', 'destination' => 'San Diego', 'price' => 99],
- ['departure' => 'Chicago', 'destination' => 'New York', 'price' => 150]
- ],
- ['departure', 'destination'],
- ['price']
-);
-```
-
-In the example above, Hypervel will attempt to insert two records. If a record already exists with the same `departure` and `destination` column values, Hypervel will update that record's `price` column.
-
-::: warning
-All databases except SQL Server require the columns in the second argument of the `upsert` method to have a "primary" or "unique" index. In addition, the MariaDB and MySQL database drivers ignore the second argument of the `upsert` method and always use the "primary" and "unique" indexes of the table to detect existing records.
-:::
-
-## Update Statements
-
-In addition to inserting records into the database, the query builder can also update existing records using the `update` method. The `update` method, like the `insert` method, accepts an array of column and value pairs indicating the columns to be updated. The `update` method returns the number of affected rows. You may constrain the `update` query using `where` clauses:
-
-```php
-$affected = DB::table('users')
- ->where('id', 1)
- ->update(['votes' => 1]);
-```
-
-#### Update or Insert
-
-Sometimes you may want to update an existing record in the database or create it if no matching record exists. In this scenario, the `updateOrInsert` method may be used. The `updateOrInsert` method accepts two arguments: an array of conditions by which to find the record, and an array of column and value pairs indicating the columns to be updated.
-
-The `updateOrInsert` method will attempt to locate a matching database record using the first argument's column and value pairs. If the record exists, it will be updated with the values in the second argument. If the record cannot be found, a new record will be inserted with the merged attributes of both arguments:
-
-```php
-DB::table('users')
- ->updateOrInsert(
- ['email' => 'john@example.com', 'name' => 'John'],
- ['votes' => '2']
- );
-```
-
-You may provide a closure to the `updateOrInsert` method to customize the attributes that are updated or inserted into the database based on the existence of a matching record:
-
-```php
-DB::table('users')->updateOrInsert(
- ['user_id' => $user_id],
- fn ($exists) => $exists ? [
- 'name' => $data['name'],
- 'email' => $data['email'],
- ] : [
- 'name' => $data['name'],
- 'email' => $data['email'],
- 'marketable' => true,
- ],
-);
-```
-
-### Updating JSON Columns
-
-When updating a JSON column, you should use `->` syntax to update the appropriate key in the JSON object. This operation is supported on MariaDB 10.3+, MySQL 5.7+, and PostgreSQL 9.5+:
-
-```php
-$affected = DB::table('users')
- ->where('id', 1)
- ->update(['options->enabled' => true]);
-```
-
-### Increment and Decrement
-
-The query builder also provides convenient methods for incrementing or decrementing the value of a given column. Both of these methods accept at least one argument: the column to modify. A second argument may be provided to specify the amount by which the column should be incremented or decremented:
-
-```php
-DB::table('users')->increment('votes');
-
-DB::table('users')->increment('votes', 5);
-
-DB::table('users')->decrement('votes');
-
-DB::table('users')->decrement('votes', 5);
-```
-
-If needed, you may also specify additional columns to update during the increment or decrement operation:
-
-```php
-DB::table('users')->increment('votes', 1, ['name' => 'John']);
-```
-
-In addition, you may increment or decrement multiple columns at once using the `incrementEach` and `decrementEach` methods:
-
-```php
-DB::table('users')->incrementEach([
- 'votes' => 5,
- 'balance' => 100,
-]);
-```
-
-## Delete Statements
-
-The query builder's `delete` method may be used to delete records from the table. The `delete` method returns the number of affected rows. You may constrain `delete` statements by adding "where" clauses before calling the `delete` method:
-
-```php
-$deleted = DB::table('users')->delete();
-
-$deleted = DB::table('users')->where('votes', '>', 100)->delete();
-```
-
-## Pessimistic Locking
-
-The query builder also includes a few functions to help you achieve "pessimistic locking" when executing your `select` statements. To execute a statement with a "shared lock", you may call the `sharedLock` method. A shared lock prevents the selected rows from being modified until your transaction is committed:
-
-```php
-DB::table('users')
- ->where('votes', '>', 100)
- ->sharedLock()
- ->get();
-```
-
-Alternatively, you may use the `lockForUpdate` method. A "for update" lock prevents the selected records from being modified or from being selected with another shared lock:
-
-```php
-DB::table('users')
- ->where('votes', '>', 100)
- ->lockForUpdate()
- ->get();
-```
-
-While not obligatory, it is recommended to wrap pessimistic locks within a [transaction](/docs/database#database-transactions). This ensures that the data retrieved remains unaltered in the database until the entire operation completes. In case of a failure, the transaction will roll back any changes and release the locks automatically:
-
-```php
-DB::transaction(function () {
- $sender = DB::table('users')
- ->lockForUpdate()
- ->find(1);
-
- $receiver = DB::table('users')
- ->lockForUpdate();
- ->find(2);
-
- if ($sender->balance < 100) {
- throw new RuntimeException('Balance too low.');
- }
-
- DB::table('users')
- ->where('id', $sender->id)
- ->update([
- 'balance' => $sender->balance - 100
- ]);
-
- DB::table('users')
- ->where('id', $receiver->id)
- ->update([
- 'balance' => $receiver->balance + 100
- ]);
-});
-```
-
-## Debugging
-
-You may use the `toSql` and `toRawSql` methods while building a query to dump the current query bindings and SQL. The `toSql` method will display the compiled sql `without` binding parameters. The `toRawSql` method will display the compiled sql `with` binding parameters:
-
-```php
-DB::table('users')->where('votes', '>', 100)->toSql();
-
-DB::table('users')->where('votes', '>', 100)->toRawSql();
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/queues.md b/_archive/docs/0.3/docs/queues.md
deleted file mode 100644
index a7b133da70..0000000000
--- a/_archive/docs/0.3/docs/queues.md
+++ /dev/null
@@ -1,2334 +0,0 @@
-# Queues
-[[toc]]
-
-## Introduction
-
-While building your web application, you may have some tasks, such as parsing and storing an uploaded CSV file, that take too long to perform during a typical web request. Thankfully, Hypervel allows you to easily create queued jobs that may be processed in the background. By moving time intensive tasks to a queue, your application can respond to web requests with blazing speed and provide a better user experience to your customers.
-
-Hypervel queues provide a unified queueing API across a variety of different queue backends, such as [Amazon SQS](https://aws.amazon.com/sqs/), [Redis](https://redis.io), or even a relational database.
-
-Hypervel's queue configuration options are stored in your application's `config/queue.php` configuration file. In this file, you will find connection configurations for each of the queue drivers that are included with the framework, including the database, [Amazon SQS](https://aws.amazon.com/sqs/), [Redis](https://redis.io), and [Beanstalkd](https://beanstalkd.github.io/) drivers, as well as a synchronous driver that will execute jobs immediately (for use during local development). A `null` queue driver is also included which discards queued jobs.
-
-For those jobs you just want to make them executed asynchronously without promising storage persistency, you can use `coroutine` or `defer` driver to run these jobs before the end of current coroutine's lifecycle. Please note defer itself is FILO, which is opposite to queue structure.
-
-::: note
-Hypervel hasn't support horizon yet.
-:::
-
-### Connections vs. Queues
-
-Before getting started with Hypervel queues, it is important to understand the distinction between "connections" and "queues". In your `config/queue.php` configuration file, there is a `connections` configuration array. This option defines the connections to backend queue services such as Amazon SQS, Beanstalk, or Redis. However, any given queue connection may have multiple "queues" which may be thought of as different stacks or piles of queued jobs.
-
-Note that each connection configuration example in the `queue` configuration file contains a `queue` attribute. This is the default queue that jobs will be dispatched to when they are sent to a given connection. In other words, if you dispatch a job without explicitly defining which queue it should be dispatched to, the job will be placed on the queue that is defined in the `queue` attribute of the connection configuration:
-
-```php
-use App\Jobs\ProcessPodcast;
-
-// This job is sent to the default connection's default queue...
-ProcessPodcast::dispatch();
-
-// This job is sent to the default connection's "emails" queue...
-ProcessPodcast::dispatch()->onQueue('emails');
-```
-
-Some applications may not need to ever push jobs onto multiple queues, instead preferring to have one simple queue. However, pushing jobs to multiple queues can be especially useful for applications that wish to prioritize or segment how jobs are processed, since the Hypervel queue worker allows you to specify which queues it should process by priority. For example, if you push jobs to a `high` queue, you may run a worker that gives them higher processing priority:
-
-```shell:no-line-numbers
-php artisan queue:work --queue=high,default
-```
-
-### Driver Notes and Prerequisites
-
-#### Database
-
-In order to use the `database` queue driver, you will need a database table to hold the jobs. To generate a migration that creates this table, run the `queue:table` Artisan command. Once the migration has been created, you may migrate your database using the `migrate` command:
-
-```shell:no-line-numbers
-php artisan queue:table
-
-php artisan migrate
-```
-
-Finally, don't forget to instruct your application to use the `database` driver by updating the `QUEUE_CONNECTION` variable in your application's `.env` file:
-
-```
-QUEUE_CONNECTION=database
-```
-
-#### Redis
-
-In order to use the `redis` queue driver, you should configure a Redis database connection in your `config/database.php` configuration file.
-
-::: warning
-The `serializer` and `compression` Redis options are not supported by the `redis` queue driver.
-:::
-
-**Redis Cluster**
-
-If your Redis queue connection uses a Redis Cluster, your queue names must contain a [key hash tag](https://redis.io/docs/reference/cluster-spec/#hash-tags). This is required in order to ensure all of the Redis keys for a given queue are placed into the same hash slot:
-
-```php
-'redis' => [
- 'driver' => 'redis',
- 'connection' => 'default',
- 'queue' => '{default}',
- 'retry_after' => 90,
-],
-```
-
-**Blocking**
-
-When using the Redis queue, you may use the `block_for` configuration option to specify how long the driver should wait for a job to become available before iterating through the worker loop and re-polling the Redis database.
-
-Adjusting this value based on your queue load can be more efficient than continually polling the Redis database for new jobs. For instance, you may set the value to `5` to indicate that the driver should block for five seconds while waiting for a job to become available:
-
-```php
-'redis' => [
- 'driver' => 'redis',
- 'connection' => 'default',
- 'queue' => 'default',
- 'retry_after' => 90,
- 'block_for' => 5,
-],
-```
-
-::: warning
-Setting `block_for` to `0` will cause queue workers to block indefinitely until a job is available. This will also prevent signals such as `SIGTERM` from being handled until the next job has been processed.
-:::
-
-#### Other Driver Prerequisites
-
-The following dependencies are needed for the listed queue drivers. These dependencies may be installed via the Composer package manager:
-
-
-
-- Amazon SQS: `aws/aws-sdk-php ~3.0`
-- Beanstalkd: `pda/pheanstalk ~4.0`
-- Redis: `predis/predis ~1.0` or phpredis PHP extension
-
-
-
-## Creating Jobs
-
-### Generating Job Classes
-
-By default, all of the queueable jobs for your application are stored in the `app/Jobs` directory. If the `app/Jobs` directory doesn't exist, it will be created when you run the `make:job` Artisan command:
-
-```shell:no-line-numbers
-php artisan make:job ProcessPodcast
-```
-
-The generated class will implement the `Hypervel\Queue\Contracts\ShouldQueue` interface, indicating to Hypervel that the job should be pushed onto the queue to run asynchronously.
-
-### Class Structure
-
-Job classes are very simple, normally containing only a `handle` method that is invoked when the job is processed by the queue. To get started, let's take a look at an example job class. In this example, we'll pretend we manage a podcast publishing service and need to process the uploaded podcast files before they are published:
-
-```php
-app->bindMethod([ProcessPodcast::class, 'handle'], function (ProcessPodcast $job, Application $app) {
- return $job->handle($app->make(AudioProcessor::class));
-});
-```
-
-::: warning
-Binary data, such as raw image contents, should be passed through the `base64_encode` function before being passed to a queued job. Otherwise, the job may not properly serialize to JSON when being placed on the queue.
-:::
-
-#### Queued Relationships
-
-Because all loaded Eloquent model relationships also get serialized when a job is queued, the serialized job string can sometimes become quite large. Furthermore, when a job is deserialized and model relationships are re-retrieved from the database, they will be retrieved in their entirety. Any previous relationship constraints that were applied before the model was serialized during the job queueing process will not be applied when the job is deserialized. Therefore, if you wish to work with a subset of a given relationship, you should re-constrain that relationship within your queued job.
-
-Or, to prevent relations from being serialized, you can call the `withoutRelations` method on the model when setting a property value. This method will return an instance of the model without its loaded relationships:
-
-```php
-/**
- * Create a new job instance.
- */
-public function __construct(Podcast $podcast)
-{
- $this->podcast = $podcast->withoutRelations();
-}
-```
-
-If a job receives a collection or array of Eloquent models instead of a single model, the models within that collection will not have their relationships restored when the job is deserialized and executed. This is to prevent excessive resource usage on jobs that deal with large numbers of models.
-
-### Unique Jobs
-
-::: warning
-Unique jobs require a cache driver that supports [locks](/docs/cache#atomic-locks). Currently, the `memcached`, `redis`, `dynamodb`, `database`, `file`, and `array` cache drivers support atomic locks. In addition, unique job constraints do not apply to jobs within batches.
-:::
-
-Sometimes, you may want to ensure that only one instance of a specific job is on the queue at any point in time. You may do so by implementing the `ShouldBeUnique` interface on your job class. This interface does not require you to define any additional methods on your class:
-
-```php
-product->id;
- }
-}
-```
-
-In the example above, the `UpdateSearchIndex` job is unique by a product ID. So, any new dispatches of the job with the same product ID will be ignored until the existing job has completed processing. In addition, if the existing job is not processed within one hour, the unique lock will be released and another job with the same unique key can be dispatched to the queue.
-
-::: warning
-If your application dispatches jobs from multiple web servers or containers, you should ensure that all of your servers are communicating with the same central cache server so that Hypervel can accurately determine if a job is unique.
-:::
-
-#### Keeping Jobs Unique Until Processing Begins
-
-By default, unique jobs are "unlocked" after a job completes processing or fails all of its retry attempts. However, there may be situations where you would like your job to unlock immediately before it is processed. To accomplish this, your job should implement the `ShouldBeUniqueUntilProcessing` contract instead of the `ShouldBeUnique` contract:
-
-```php
-block(0)->allow(1)->every(5)
- ->then(function () use ($job, $next) {
- // Lock obtained...
-
- $next($job);
- }, function () use ($job) {
- // Could not obtain lock...
-
- $job->release(5);
- });
- }
-}
-```
-
-As you can see, like [route middleware](/docs/middleware), job middleware receive the job being processed and a callback that should be invoked to continue processing the job.
-
-After creating job middleware, they may be attached to a job by returning them from the job's `middleware` method. This method does not exist on jobs scaffolded by the `make:job` Artisan command, so you will need to manually add it to your job class:
-
-```php
-use App\Jobs\Middleware\RateLimited;
-
-/**
- * Get the middleware the job should pass through.
- *
- * @return array
-
-Method | Description
-------------- | -------------
-`->cron('* * * * *');` | Run the task on a custom cron schedule
-`->everySecond();` | Run the task every second
-`->everyTwoSeconds();` | Run the task every two seconds
-`->everyFiveSeconds();` | Run the task every five seconds
-`->everyTenSeconds();` | Run the task every ten seconds
-`->everyFifteenSeconds();` | Run the task every fifteen seconds
-`->everyTwentySeconds();` | Run the task every twenty seconds
-`->everyThirtySeconds();` | Run the task every thirty seconds
-`->everyMinute();` | Run the task every minute
-`->everyTwoMinutes();` | Run the task every two minutes
-`->everyThreeMinutes();` | Run the task every three minutes
-`->everyFourMinutes();` | Run the task every four minutes
-`->everyFiveMinutes();` | Run the task every five minutes
-`->everyTenMinutes();` | Run the task every ten minutes
-`->everyFifteenMinutes();` | Run the task every fifteen minutes
-`->everyThirtyMinutes();` | Run the task every thirty minutes
-`->hourly();` | Run the task every hour
-`->hourlyAt(17);` | Run the task every hour at 17 minutes past the hour
-`->everyOddHour($minutes = 0);` | Run the task every odd hour
-`->everyTwoHours($minutes = 0);` | Run the task every two hours
-`->everyThreeHours($minutes = 0);` | Run the task every three hours
-`->everyFourHours($minutes = 0);` | Run the task every four hours
-`->everySixHours($minutes = 0);` | Run the task every six hours
-`->daily();` | Run the task every day at midnight
-`->dailyAt('13:00');` | Run the task every day at 13:00
-`->twiceDaily(1, 13);` | Run the task daily at 1:00 & 13:00
-`->twiceDailyAt(1, 13, 15);` | Run the task daily at 1:15 & 13:15
-`->weekly();` | Run the task every Sunday at 00:00
-`->weeklyOn(1, '8:00');` | Run the task every week on Monday at 8:00
-`->monthly();` | Run the task on the first day of every month at 00:00
-`->monthlyOn(4, '15:00');` | Run the task every month on the 4th at 15:00
-`->twiceMonthly(1, 16, '13:00');` | Run the task monthly on the 1st and 16th at 13:00
-`->lastDayOfMonth('15:00');` | Run the task on the last day of the month at 15:00
-`->quarterly();` | Run the task on the first day of every quarter at 00:00
-`->quarterlyOn(4, '14:00');` | Run the task every quarter on the 4th at 14:00
-`->yearly();` | Run the task on the first day of every year at 00:00
-`->yearlyOn(6, 1, '17:00');` | Run the task every year on June 1st at 17:00
-`->timezone('America/New_York');` | Set the timezone for the task
-
-
-
-These methods may be combined with additional constraints to create even more finely tuned schedules that only run on certain days of the week. For example, you may schedule a command to run weekly on Monday:
-
-```php
-// Run once per week on Monday at 1 PM...
-$schedule->call(function () {
- // ...
-})->weekly()->mondays()->at('13:00');
-
-// Run hourly from 8 AM to 5 PM on weekdays...
-$schedule->command('foo')
- ->weekdays()
- ->hourly()
- ->timezone('America/Chicago')
- ->between('8:00', '17:00');
-```
-
-A list of additional schedule constraints may be found below:
-
-
-
-Method | Description
-------------- | -------------
-`->weekdays();` | Limit the task to weekdays
-`->weekends();` | Limit the task to weekends
-`->sundays();` | Limit the task to Sunday
-`->mondays();` | Limit the task to Monday
-`->tuesdays();` | Limit the task to Tuesday
-`->wednesdays();` | Limit the task to Wednesday
-`->thursdays();` | Limit the task to Thursday
-`->fridays();` | Limit the task to Friday
-`->saturdays();` | Limit the task to Saturday
-`->days(array\|mixed);` | Limit the task to specific days
-`->between($startTime, $endTime);` | Limit the task to run between start and end times
-`->unlessBetween($startTime, $endTime);` | Limit the task to not run between start and end times
-`->when(Closure);` | Limit the task based on a truth test
-`->environments($env);` | Limit the task to specific environments
-
-
-
-#### Day Constraints
-
-The `days` method may be used to limit the execution of a task to specific days of the week. For example, you may schedule a command to run hourly on Sundays and Wednesdays:
-
-```php
-$schedule->command('emails:send')
- ->hourly()
- ->days([0, 3]);
-```
-
-Alternatively, you may use the constants available on the `Hypervel\Console\Scheduling\Schedule` class when defining the days on which a task should run:
-
-```php
-use Hypervel\Console\Scheduling\Schedule;
-
-$schedule->command('emails:send')
- ->hourly()
- ->days([Schedule::SUNDAY, Schedule::WEDNESDAY]);
-```
-
-#### Between Time Constraints
-
-The `between` method may be used to limit the execution of a task based on the time of day:
-
-```php
-$schedule->command('emails:send')
- ->hourly()
- ->between('7:00', '22:00');
-```
-
-Similarly, the `unlessBetween` method can be used to exclude the execution of a task for a period of time:
-
-```php
-$schedule->command('emails:send')
- ->hourly()
- ->unlessBetween('23:00', '4:00');
-```
-
-#### Truth Test Constraints
-
-The `when` method may be used to limit the execution of a task based on the result of a given truth test. In other words, if the given closure returns `true`, the task will execute as long as no other constraining conditions prevent the task from running:
-
-```php
-$schedule->command('emails:send')->daily()->when(function () {
- return true;
-});
-```
-
-The `skip` method may be seen as the inverse of `when`. If the `skip` method returns `true`, the scheduled task will not be executed:
-
-```php
-$schedule->command('emails:send')->daily()->skip(function () {
- return true;
-});
-```
-
-When using chained `when` methods, the scheduled command will only execute if all `when` conditions return `true`.
-
-#### Environment Constraints
-
-The `environments` method may be used to execute tasks only on the given environments (as defined by the `APP_ENV` [environment variable](/docs/configuration#environment-configuration)):
-
-```php
-$schedule->command('emails:send')
- ->daily()
- ->environments(['staging', 'production']);
-```
-
-### Timezones
-
-Using the `timezone` method, you may specify that a scheduled task's time should be interpreted within a given timezone:
-
-```php
-$schedule->command('report:generate')
- ->timezone('America/New_York')
- ->at('2:00')
-```
-
-If you are repeatedly assigning the same timezone to all of your scheduled tasks, you may wish to define a `scheduleTimezone` method in your `App\Console\Kernel` class. This method should return the default timezone that should be assigned to all scheduled tasks:
-
-```php
-use DateTimeZone;
-
-/**
- * Get the timezone that should be used by default for scheduled events.
- */
-protected function scheduleTimezone(): DateTimeZone|string|null
-{
- return 'America/Chicago';
-}
-```
-
-::: warning
-Remember that some timezones utilize daylight savings time. When daylight saving time changes occur, your scheduled task may run twice or even not run at all. For this reason, we recommend avoiding timezone scheduling when possible.
-:::
-
-### Preventing Task Overlaps
-
-By default, scheduled tasks will be run even if the previous instance of the task is still running. To prevent this, you may use the `withoutOverlapping` method:
-
-```php
-$schedule->command('emails:send')->withoutOverlapping();
-```
-
-In this example, the `emails:send` [Artisan command](/docs/artisan) will be run every minute if it is not already running. The `withoutOverlapping` method is especially useful if you have tasks that vary drastically in their execution time, preventing you from predicting exactly how long a given task will take.
-
-If needed, you may specify how many minutes must pass before the "without overlapping" lock expires. By default, the lock will expire after 24 hours:
-
-```php
-$schedule->command('emails:send')->withoutOverlapping(10);
-```
-
-Behind the scenes, the `withoutOverlapping` method utilizes your application's [cache](/docs/cache) to obtain locks. If necessary, you can clear these cache locks using the `schedule:clear-cache` Artisan command. This is typically only necessary if a task becomes stuck due to an unexpected server problem.
-
-### Running Tasks on One Server
-
-::: warning
-To utilize this feature, your application must be using the `database`, `memcached`, `dynamodb`, or `redis` cache driver as your application's default cache driver. In addition, all servers must be communicating with the same central cache server.
-:::
-
-If your application's scheduler is running on multiple servers, you may limit a scheduled job to only execute on a single server. For instance, assume you have a scheduled task that generates a new report every Friday night. If the task scheduler is running on three worker servers, the scheduled task will run on all three servers and generate the report three times. Not good!
-
-To indicate that the task should run on only one server, use the `onOneServer` method when defining the scheduled task. The first server to obtain the task will secure an atomic lock on the job to prevent other servers from running the same task at the same time:
-
-```php
-$schedule->command('report:generate')
- ->fridays()
- ->at('17:00')
- ->onOneServer();
-```
-
-#### Naming Single Server Jobs
-
-Sometimes you may need to schedule the same job to be dispatched with different parameters, while still instructing Hypervel to run each permutation of the job on a single server. To accomplish this, you may assign each schedule definition a unique name via the `name` method:
-
-```php
-$schedule->job(new CheckUptime('https://hypervel.org'))
- ->name('check_uptime:hypervel.org')
- ->everyFiveMinutes()
- ->onOneServer();
-
-$schedule->job(new CheckUptime('https://hypervel.org'))
- ->name('check_uptime:hypervel.org')
- ->everyFiveMinutes()
- ->onOneServer();
-```
-
-Similarly, scheduled closures must be assigned a name if they are intended to be run on one server:
-
-```php
-$schedule->call(fn () => User::resetApiRequestCount())
- ->name('reset-api-request-count')
- ->daily()
- ->onOneServer();
-```
-
-### Background Tasks
-
-By default, multiple tasks scheduled at the same time will execute sequentially based on the order they are defined in your `schedule` method. If you have long-running tasks, this may cause subsequent tasks to start much later than anticipated. If you would like to run tasks in the background so that they may all run simultaneously, you may use the `runInBackground` method:
-
-```php
-$schedule->command('analytics:report')
- ->daily()
- ->runInBackground();
-```
-
-::: warning
-The `runInBackground` method may only be used when scheduling tasks via the `command` and `exec` methods.
-:::
-
-::: info
-Unlike in Laravel, all the background tasks are executed in coroutines. It's much more efficient when you need to run many background tasks simultaneously in intensive I/O scenes.
-:::
-
-## Running the Scheduler
-
-Now that we have learned how to define scheduled tasks, let's discuss how to actually run them on our server. The `schedule:run` Artisan command will evaluate all of your scheduled tasks and determine if they need to run based on the server's current time.
-
-So, when using Hypervel's scheduler, we only need to run the `schedule:run` command and a scheduler will be running and waiting for the upcoming scheduling tasks constantly.
-
-```shell
-php artisan schedule:run
-```
-
-::: warning
-In Laravel, `schedule:run` is designed for running in system's cron jobs. However, in Hypervel it's designed as a long-running process.
-:::
-
-
-If you prefer to run the scheduler in traditional system's scheduler, you can also add a single cron configuration entry to our server that runs the `schedule:run --once` command every minute.
-
-```shell
-* * * * * cd /path-to-your-project && php artisan schedule:run --once >> /dev/null 2>&1
-```
-
-#### Concurrent Processing in the Scheduler
-
-Different from Laravel, all the background processes will be executed in coroutines instead of processes. The majority of background processing is I/O bound scenario. Running in tasks in coroutines is much more efficient than processes.
-
-By default the concurrency number for coroutines is set to `60`, which means you can have 60 running coroutines at the same time. You can configure this number when you run the scheduling command:
-
-```shell:no-line-numbers
-php artisan schedule:run --concurrency=100
-```
-
-For CPU-bound queue jobs, coroutines offer limited performance benefits. You can run these tasks using system commands using `exec`, then the task will be executed in a new background process:
-
-```php
-$schedule->exec('php artisan calculate-command')
- ->runInBackground();
-```
-
-### Sub-Minute Scheduled Tasks
-
-On most operating systems, cron jobs are limited to running a maximum of once per minute. However, Hypervel's scheduler allows you to schedule tasks to run at more frequent intervals, even as often as once per second:
-
-```php
-$schedule->call(function () {
- DB::table('recent_users')->delete();
-})->everySecond();
-```
-
-### Stopping Tasks
-
-As the `schedule:run` command runs constantly for handling upcoming tasks, you may sometimes need to stop the command when deploying your application.
-
-To stop in-progress `schedule:run` invocations, you may add the `schedule:stop` command to your application's deployment script. This command should be invoked after your application is finished deploying:
-
-```shell
-php artisan schedule:stop
-```
-
-After receiving a stop signal, the scheduler will wait for unfinished tasks to complete before exiting.
-
-## Task Output
-
-The Hypervel scheduler provides several convenient methods for working with the output generated by scheduled tasks. First, using the `sendOutputTo` method, you may send the output to a file for later inspection:
-
-```php
-$schedule->command('emails:send')
- ->daily()
- ->sendOutputTo($filePath);
-```
-
-If you would like to append the output to a given file, you may use the `appendOutputTo` method:
-
-```php
-$schedule->command('emails:send')
- ->daily()
- ->appendOutputTo($filePath);
-```
-
-Using the `emailOutputTo` method, you may email the output to an email address of your choice. Before emailing the output of a task, you should configure Hypervel's [email services](/docs/mail):
-
-```php
-$schedule->command('report:generate')
- ->daily()
- ->sendOutputTo($filePath)
- ->emailOutputTo('taylor@example.com');
-```
-
-If you only want to email the output if the scheduled Artisan or system command terminates with a non-zero exit code, use the `emailOutputOnFailure` method:
-
-```php
-$schedule->command('report:generate')
- ->daily()
- ->emailOutputOnFailure('taylor@example.com');
-```
-
-::: warning
-The `emailOutputTo`, `emailOutputOnFailure`, `sendOutputTo`, and `appendOutputTo` methods are exclusive to the `command` and `exec` methods.
-:::
-
-## Task Hooks
-
-Using the `before` and `after` methods, you may specify code to be executed before and after the scheduled task is executed:
-
-```php
-$schedule->command('emails:send')
- ->daily()
- ->before(function () {
- // The task is about to execute...
- })
- ->after(function () {
- // The task has executed...
- });
-```
-
-The `onSuccess` and `onFailure` methods allow you to specify code to be executed if the scheduled task succeeds or fails. A failure indicates that the scheduled Artisan or system command terminated with a non-zero exit code:
-
-```php
-$schedule->command('emails:send')
- ->daily()
- ->onSuccess(function () {
- // The task succeeded...
- })
- ->onFailure(function () {
- // The task failed...
- });
-```
-
-If output is available from your command, you may access it in your `after`, `onSuccess` or `onFailure` hooks by type-hinting an `Hypervel\Support\Stringable` instance as the `$output` argument of your hook's closure definition:
-
-```php
-use Hypervel\Support\Stringable;
-
-$schedule->command('emails:send')
- ->daily()
- ->onSuccess(function (Stringable $output) {
- // The task succeeded...
- })
- ->onFailure(function (Stringable $output) {
- // The task failed...
- });
-```
-
-#### Pinging URLs
-
-Using the `pingBefore` and `thenPing` methods, the scheduler can automatically ping a given URL before or after a task is executed. This method is useful for notifying an external service, such as [Healthchecks](https://healthchecks.io/), that your scheduled task is beginning or has finished execution:
-
-```php
-$schedule->command('emails:send')
- ->daily()
- ->pingBefore($url)
- ->thenPing($url);
-```
-
-The `pingBeforeIf` and `thenPingIf` methods may be used to ping a given URL only if a given condition is `true`:
-
-```php
-$schedule->command('emails:send')
- ->daily()
- ->pingBeforeIf($condition, $url)
- ->thenPingIf($condition, $url);
-```
-
-The `pingOnSuccess` and `pingOnFailure` methods may be used to ping a given URL only if the task succeeds or fails. A failure indicates that the scheduled Artisan or system command terminated with a non-zero exit code:
-
-```php
-$schedule->command('emails:send')
- ->daily()
- ->pingOnSuccess($successUrl)
- ->pingOnFailure($failureUrl);
-```
-
-All of the ping methods require the Guzzle HTTP library. Guzzle is typically installed in all new Hypervel projects by default, but, you may manually install Guzzle into your project using the Composer package manager if it has been accidentally removed:
-
-```shell
-composer require guzzlehttp/guzzle
-```
-
-## Events
-
-If needed, you may listen to [events](/docs/events) dispatched by the scheduler. Typically, event listener mappings will be defined within your application's `App\Providers\EventServiceProvider` class:
-
-```php
-/**
- * The event listener mappings for the application.
- */
-protected array $listen = [
- 'Hypervel\Console\Events\ScheduledTaskStarting' => [
- 'App\Listeners\LogScheduledTaskStarting',
- ],
-
- 'Hypervel\Console\Events\ScheduledTaskFinished' => [
- 'App\Listeners\LogScheduledTaskFinished',
- ],
-
- 'Hypervel\Console\Events\ScheduledTaskSkipped' => [
- 'App\Listeners\LogScheduledTaskSkipped',
- ],
-
- 'Hypervel\Console\Events\ScheduledTaskFailed' => [
- 'App\Listeners\LogScheduledTaskFailed',
- ],
-];
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/seeding.md b/_archive/docs/0.3/docs/seeding.md
deleted file mode 100644
index 3737a69b0a..0000000000
--- a/_archive/docs/0.3/docs/seeding.md
+++ /dev/null
@@ -1,114 +0,0 @@
-# Database: Seeding
-[[toc]]
-
-## Introduction
-
-Hypervel includes the ability to seed your database with data using seed classes. All seed classes are stored in the `database/seeders` directory. By default, a `DatabaseSeeder` class is defined for you. From this class, you may use the `call` method to run other seed classes, allowing you to control the seeding order.
-
-::: note
-[Mass assignment protection](/docs/eloquent#mass-assignment) is automatically disabled during database seeding.
-:::
-
-## Writing Seeders
-
-To generate a seeder, execute the `make:seeder` [Artisan command](/docs/artisan). All seeders generated by the framework will be placed in the `database/seeders` directory:
-
-```shell:no-line-numbers
-php artisan make:seeder UserSeeder
-```
-
-A seeder class only contains one method by default: `run`. This method is called when the `db:seed` [Artisan command](/docs/artisan) is executed. Within the `run` method, you may insert data into your database however you wish. You may use the [query builder](/docs/queries) to manually insert data or you may use [Eloquent model factories](/docs/eloquent-factories).
-
-As an example, let's modify the default `DatabaseSeeder` class and add a database insert statement to the `run` method:
-
-```php
-insert([
- 'name' => Str::random(10),
- 'email' => Str::random(10).'@example.com',
- 'password' => Hash::make('password'),
- ]);
- }
-}
-```
-
-::: note
-You may type-hint any dependencies you need within the `run` method's signature. They will automatically be resolved via the Hypervel [service container](/docs/container).
-:::
-
-### Using Model Factories
-
-Of course, manually specifying the attributes for each model seed is cumbersome. Instead, you can use [model factories](/docs/eloquent-factories) to conveniently generate large amounts of database records. First, review the [model factory documentation](/docs/eloquent-factories) to learn how to define your factories.
-
-For example, let's create 50 users:
-
-```php
-use App\Models\User;
-
-/**
- * Run the database seeders.
- */
-public function run(): void
-{
- User::factory()->create();
-}
-```
-
-### Calling Additional Seeders
-
-Within the `DatabaseSeeder` class, you may use the `call` method to execute additional seed classes. Using the `call` method allows you to break up your database seeding into multiple files so that no single seeder class becomes too large. The `call` method accepts an array of seeder classes that should be executed:
-
-```php
-/**
- * Run the database seeders.
- */
-public function run(): void
-{
- $this->call([
- UserSeeder::class,
- PostSeeder::class,
- CommentSeeder::class,
- ]);
-}
-```
-
-## Running Seeders
-
-You may execute the `db:seed` Artisan command to seed your database. By default, the `db:seed` command runs the `Database\Seeders\DatabaseSeeder` class, which may in turn invoke other seed classes. However, you may use the `--class` option to specify a specific seeder class to run individually:
-
-```shell:no-line-numbers
-php artisan db:seed
-
-php artisan db:seed --class=UserSeeder
-```
-
-You may also seed your database using the `migrate:fresh` command in combination with the `--seed` option, which will drop all tables and re-run all of your migrations. This command is useful for completely re-building your database. The `--seeder` option may be used to specify a specific seeder to run:
-
-```shell:no-line-numbers
-php artisan migrate:fresh --seed
-
-php artisan migrate:fresh --seed --seeder=UserSeeder
-```
-
-#### Forcing Seeders to Run in Production
-
-Some seeding operations may cause you to alter or lose data. In order to protect you from running seeding commands against your production database, you will be prompted for confirmation before the seeders are executed in the `production` environment. To force the seeders to run without a prompt, use the `--force` flag:
-
-```shell:no-line-numbers
-php artisan db:seed --force
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/session.md b/_archive/docs/0.3/docs/session.md
deleted file mode 100644
index c30cf8f076..0000000000
--- a/_archive/docs/0.3/docs/session.md
+++ /dev/null
@@ -1,373 +0,0 @@
-# Session
-[[toc]]
-
-## Introduction
-
-Since HTTP driven applications are stateless, sessions provide a way to store information about the user across multiple requests. That user information is typically placed in a persistent store / backend that can be accessed from subsequent requests.
-
-Hypervel ships with a variety of session backends that are accessed through an expressive, unified API. Support for popular backends such as [Redis](https://redis.io), file, and databases is included.
-
-### Configuration
-
-Your application's session configuration file is stored at `config/session.php`. Be sure to review the options available to you in this file. By default, Hypervel is configured to use the `file` session driver, which will work well for many applications. If your application will be load balanced across multiple web servers, you a centralized store that all servers can access, such as Redis or a database.
-
-::: info
-It's recommended to use `redis` as the session driver if possible, it will have better performance and scalability.
-:::
-
-The session `driver` configuration option defines where session data will be stored for each request. Hypervel ships with some great drivers out of the box:
-
-- `file` - sessions are stored in `storage/framework/sessions`.
-- `cookie` - sessions are stored in secure cookies.
-- `database` - sessions are stored in a relational database.
-- `redis` - sessions are stored in redis, a fast and cache based store.
-- `array` - sessions are stored in a PHP array and will not be persisted.
-
-::: important
-Before using session, you need to enable the `Hypervel\Session\Middleware\StartSession` middleware in `Kernel.php`.
-:::
-
-::: tip
-The array driver is primarily used during [testing](/docs/testing) and prevents the data stored in the session from being persisted.
-:::
-
-### Driver Prerequisites
-
-#### Database
-
-When using the `database` session driver, you will need to create a table to contain the session records. An example `Schema` declaration for the table may be found below:
-
-```php
-use Hyperf\Database\Schema\Blueprint;
-use Hypervel\Support\Facades\Schema;
-
-Schema::create('sessions', function (Blueprint $table) {
- $table->string('id')->primary();
- $table->foreignId('user_id')->nullable()->index();
- $table->string('ip_address', 45)->nullable();
- $table->text('user_agent')->nullable();
- $table->longText('payload');
- $table->integer('last_activity')->index();
-});
-```
-
-You may use the `session:table` Artisan command to generate this migration. To learn more about database migrations, you may consult the complete [migration documentation](/docs/migrations):
-
-```shell
-php artisan session:table
-
-php artisan migrate
-```
-
-#### Redis
-
-Before using Redis sessions with Hypervel, you will need to either install the PhpRedis PHP extension via PECL. For more information on configuring Redis, consult Hypervel's [Redis documentation](/docs/redis#configuration).
-
-::: note
-In the `session` configuration file, the `connection` option may be used to specify which Redis connection is used by the session.
-:::
-
-## Interacting With the Session
-
-### Retrieving Data
-
-There are two primary ways of working with session data in Hypervel: the global `session` helper and via a `Request` instance. First, let's look at accessing the session via a `Request` instance, which can be type-hinted on a route closure or controller method. Remember, controller method dependencies are automatically injected via the Hypervel [service container](/docs/container):
-
-```php
-session()->get('key');
-
- // ...
-
- $user = $this->users->find($id);
-
- return view('user.profile', ['user' => $user]);
- }
-}
-```
-
-When you retrieve an item from the session, you may also pass a default value as the second argument to the `get` method. This default value will be returned if the specified key does not exist in the session. If you pass a closure as the default value to the `get` method and the requested key does not exist, the closure will be executed and its result returned:
-
-```php
-$value = $request->session()->get('key', 'default');
-
-$value = $request->session()->get('key', function () {
- return 'default';
-});
-```
-
-#### The Global Session Helper
-
-You may also use the global `session` PHP function to retrieve and store data in the session. When the `session` helper is called with a single, string argument, it will return the value of that session key. When the helper is called with an array of key / value pairs, those values will be stored in the session:
-
-```php
-Route::get('/home', function () {
- // Retrieve a piece of data from the session...
- $value = session('key');
-
- // Specifying a default value...
- $value = session('key', 'default');
-
- // Store a piece of data in the session...
- session(['key' => 'value']);
-});
-```
-
-::: tip
-There is little practical difference between using the session via an HTTP request instance versus using the global `session` helper. Both methods are [testable](/docs/testing) via the `assertSessionHas` method which is available in all of your test cases.
-:::
-
-#### Retrieving All Session Data
-
-If you would like to retrieve all the data in the session, you may use the `all` method:
-
-```php
-$data = $request->session()->all();
-```
-
-#### Retrieving a Portion of the Session Data
-
-The `only` and `except` methods may be used to retrieve a subset of the session data:
-
-```php
-$data = $request->session()->only(['username', 'email']);
-
-$data = $request->session()->except(['username', 'email']);
-```
-
-#### Determining if an Item Exists in the Session
-
-To determine if an item is present in the session, you may use the `has` method. The `has` method returns `true` if the item is present and is not `null`:
-
-```php
-if ($request->session()->has('users')) {
- // ...
-}
-```
-
-To determine if an item is present in the session, even if its value is `null`, you may use the `exists` method:
-
-```php
-if ($request->session()->exists('users')) {
- // ...
-}
-```
-
-To determine if an item is not present in the session, you may use the `missing` method. The `missing` method returns true if the item is not present:
-
-```php
-if ($request->session()->missing('users')) {
- // ...
-}
-```
-
-### Storing Data
-
-To store data in the session, you will typically use the request instance's `put` method or the global `session` helper:
-
-```php
-// Via a request instance...
-$request->session()->put('key', 'value');
-
-// Via the global "session" helper...
-session(['key' => 'value']);
-```
-
-#### Pushing to Array Session Values
-
-The `push` method may be used to push a new value onto a session value that is an array. For example, if the `user.teams` key contains an array of team names, you may push a new value onto the array like so:
-
-```php
-$request->session()->push('user.teams', 'developers');
-```
-
-#### Retrieving and Deleting an Item
-
-The `remove` method will retrieve and delete an item from the session in a single statement:
-
-```php
-$value = $request->session()->pull('key', 'default');
-```
-
-#### Incrementing and Decrementing Session Values
-
-If your session data contains an integer you wish to increment or decrement, you may use the `increment` and `decrement` methods:
-
-```php
-$request->session()->increment('count');
-
-$request->session()->increment('count', $incrementBy = 2);
-
-$request->session()->decrement('count');
-
-$request->session()->decrement('count', $decrementBy = 2);
-```
-
-### Flash Data
-
-Sometimes you may wish to store items in the session for the next request. You may do so using the `flash` method. Data stored in the session using this method will be available immediately and during the subsequent HTTP request. After the subsequent HTTP request, the flashed data will be deleted. Flash data is primarily useful for short-lived status messages:
-
-```php
-$request->session()->flash('status', 'Task was successful!');
-```
-
-If you need to persist your flash data for several requests, you may use the `reflash` method, which will keep all of the flash data for an additional request. If you only need to keep specific flash data, you may use the `keep` method:
-
-```php
-$request->session()->reflash();
-
-$request->session()->keep(['username', 'email']);
-```
-
-To persist your flash data only for the current request, you may use the `now` method:
-
-```php
-$request->session()->now('status', 'Task was successful!');
-```
-
-### Deleting Data
-
-The `forget` method will remove a piece of data from the session. If you would like to remove all data from the session, you may use the `flush` method:
-
-```php
-// Forget a single key...
-$request->session()->forget('name');
-
-// Forget multiple keys...
-$request->session()->forget(['name', 'status']);
-
-$request->session()->flush();
-```
-
-### Regenerating the Session ID
-
-Regenerating the session ID is often done in order to prevent malicious users from exploiting a [session fixation](https://owasp.org/www-community/attacks/Session_fixation) attack on your application.
-
-If you need to manually regenerate the session ID, you may use the `regenerate` method:
-
-```php
-$request->session()->regenerate();
-```
-
-If you need to regenerate the session ID and remove all data from the session in a single statement, you may use the `invalidate` method:
-
-```php
-$request->session()->invalidate();
-```
-
-## Session Blocking
-
-::: warning
-To utilize session blocking, your application must be using a cache driver that supports [atomic locks](/docs/cache#atomic-locks). Currently, those cache drivers include the `redis`, `database`, `file`, and `array` drivers. In addition, you may not use the `cookie` session driver.
-:::
-
-By default, Hypervel allows requests using the same session to execute concurrently. So, for example, if you use a JavaScript HTTP library to make two HTTP requests to your application, they will both execute at the same time. For many applications, this is not a problem; however, session data loss can occur in a small subset of applications that make concurrent requests to two different application endpoints which both write data to the session.
-
-To mitigate this, Hypervel provides functionality that allows you to limit concurrent requests for a given session. To get started, you may simply set the `block` option onto your route definition. In this example, an incoming request to the `/profile` endpoint would acquire a session lock. While this lock is being held, any incoming requests to the `/profile` or `/order` endpoints which share the same session ID will wait for the first request to finish executing before continuing their execution:
-
-```php
-Route::post('/profile', function () {
- // ...
-}, ['block' => ['lock' => 10, 'wait' => 10]]);
-
-Route::post('/order', function () {
- // ...
-}, ['block' => ['lock' => 10, 'wait' => 10]]);
-```
-
-The `block` option accepts two optional configs. The `lock` config accepted by the `block` method is the maximum number of seconds the session lock should be held for before it is released. Of course, if the request finishes executing before this time the lock will be released earlier.
-
-The `wait` config accepted by the `block` method is the number of seconds a request should wait while attempting to obtain a session lock. An `Hypervel\Cache\Exceptions` will be thrown if the request is unable to obtain a session lock within the given number of seconds.
-
-If neither of these arguments is passed, the lock will be obtained for a maximum of 10 seconds and requests will wait a maximum of 10 seconds while attempting to obtain a lock:
-
-```php
-Route::post('/profile', function () {
- // ...
-}, ['block' => true]);
-```
-
-## Adding Custom Session Drivers
-
-### Implementing the Driver
-
-If none of the existing session drivers fit your application's needs, Laravel makes it possible to write your own session handler. Your custom session driver should implement PHP's built-in `SessionHandlerInterface`. This interface contains just a few simple methods. A stubbed MongoDB implementation looks like the following:
-
-```php
- [
- 'client_id' => env('GITHUB_CLIENT_ID'),
- 'client_secret' => env('GITHUB_CLIENT_SECRET'),
- 'redirect' => 'http://example.com/callback-url',
-],
-```
-
-::: note
-If the `redirect` option contains a relative path, it will automatically be resolved to a fully qualified URL.
-:::
-
-## Authentication
-
-### Routing
-
-To authenticate users using an OAuth provider, you will need two routes: one for redirecting the user to the OAuth provider, and another for receiving the callback from the provider after authentication. The example routes below demonstrate the implementation of both routes:
-
-```php
-use Hypervel\Socialite\Facades\Socialite;
-
-Route::get('/auth/redirect', function () {
- return Socialite::driver('github')->redirect();
-});
-
-Route::get('/auth/callback', function () {
- $user = Socialite::driver('github')->user();
-
- // $user->token
-});
-```
-
-The `redirect` method provided by the `Socialite` facade takes care of redirecting the user to the OAuth provider, while the `user` method will examine the incoming request and retrieve the user's information from the provider after they have approved the authentication request.
-
-### Authentication and Storage
-
-Once the user has been retrieved from the OAuth provider, you may determine if the user exists in your application's database and [authenticate the user](/docs/authentication#authenticate-a-user-instance). If the user does not exist in your application's database, you will typically create a new record in your database to represent the user:
-
-```php
-use App\Models\User;
-use Hypervel\Support\Facades\Auth;
-use Hypervel\Socialite\Facades\Socialite;
-
-Route::get('/auth/callback', function () {
- $githubUser = Socialite::driver('github')->user();
-
- $user = User::updateOrCreate([
- 'github_id' => $githubUser->id,
- ], [
- 'name' => $githubUser->name,
- 'email' => $githubUser->email,
- 'github_token' => $githubUser->token,
- 'github_refresh_token' => $githubUser->refreshToken,
- ]);
-
- Auth::login($user);
-
- return redirect('/dashboard');
-});
-```
-
-::: note
-For more information regarding what user information is available from specific OAuth providers, please consult the documentation on [retrieving user details](#retrieving-user-details).
-:::
-
-### Access Scopes
-
-Before redirecting the user, you may use the `scopes` method to specify the "scopes" that should be included in the authentication request. This method will merge all previously specified scopes with the scopes that you specify:
-
-```php
-use Hypervel\Socialite\Facades\Socialite;
-
-return Socialite::driver('github')
- ->scopes(['read:user', 'public_repo'])
- ->redirect();
-```
-
-You can overwrite all existing scopes on the authentication request using the `setScopes` method:
-
-```php
-return Socialite::driver('github')
- ->setScopes(['read:user', 'public_repo'])
- ->redirect();
-```
-
-### Slack Bot Scopes
-
-Slack's API provides [different types of access tokens](https://api.slack.com/authentication/token-types), each with their own set of [permission scopes](https://api.slack.com/scopes). Socialite is compatible with both of the following Slack access tokens types:
-
-
-
-- Bot (prefixed with `xoxb-`)
-- User (prefixed with `xoxp-`)
-
-
-
-By default, the `slack` driver will generate a `user` token and invoking the driver's `user` method will return the user's details.
-
-Bot tokens are primarily useful if your application will be sending notifications to external Slack workspaces that are owned by your application's users. To generate a bot token, invoke the `asBotUser` method before redirecting the user to Slack for authentication:
-
-```php
-return Socialite::driver('slack')
- ->asBotUser()
- ->setScopes(['chat:write', 'chat:write.public', 'chat:write.customize'])
- ->redirect();
-```
-
-In addition, you must invoke the `asBotUser` method before invoking the `user` method after Slack redirects the user back to your application after authentication:
-
-```php
-$user = Socialite::driver('slack')->asBotUser()->user();
-```
-
-When generating a bot token, the `user` method will still return a `Hypervel\Socialite\Two\User` instance; however, only the `token` property will be hydrated. This token may be stored in order to [send notifications to the authenticated user's Slack workspaces](/docs/notifications#notifying-external-slack-workspaces).
-
-### Optional Parameters
-
-A number of OAuth providers support other optional parameters on the redirect request. To include any optional parameters in the request, call the `with` method with an associative array:
-
-```php
-use Hypervel\Socialite\Facades\Socialite;
-
-return Socialite::driver('google')
- ->with(['hd' => 'example.com'])
- ->redirect();
-```
-
-::: warning
-When using the `with` method, be careful not to pass any reserved keywords such as `state` or `response_type`.
-:::
-
-## Retrieving User Details
-
-After the user is redirected back to your application's authentication callback route, you may retrieve the user's details using Socialite's `user` method. The user object returned by the `user` method provides a variety of properties and methods you may use to store information about the user in your own database.
-
-Differing properties and methods may be available on this object depending on whether the OAuth provider you are authenticating with supports OAuth 1.0 or OAuth 2.0:
-
-```php
-use Hypervel\Socialite\Facades\Socialite;
-
-Route::get('/auth/callback', function () {
- $user = Socialite::driver('github')->user();
-
- // OAuth 2.0 providers...
- $token = $user->token;
- $refreshToken = $user->refreshToken;
- $expiresIn = $user->expiresIn;
-
- // OAuth 1.0 providers...
- $token = $user->token;
- $tokenSecret = $user->tokenSecret;
-
- // All providers...
- $user->getId();
- $user->getNickname();
- $user->getName();
- $user->getEmail();
- $user->getAvatar();
-});
-```
-
-#### Retrieving User Details From a Token
-
-If you already have a valid access token for a user, you can retrieve their user details using Socialite's `userFromToken` method:
-
-```php
-use Hypervel\Socialite\Facades\Socialite;
-
-$user = Socialite::driver('github')->userFromToken($token);
-```
-
-If you are using Facebook Limited Login via an iOS application, Facebook will return an OIDC token instead of an access token. Like an access token, the OIDC token can be provided to the `userFromToken` method in order to retrieve user details.
-
-#### Stateless Authentication
-
-The `stateless` method may be used to disable session state verification. This is useful when adding social authentication to a stateless API that does not utilize cookie based sessions:
-
-```php
-use Hypervel\Socialite\Facades\Socialite;
-
-return Socialite::driver('google')->stateless()->user();
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/strings.md b/_archive/docs/0.3/docs/strings.md
deleted file mode 100644
index 467da0f754..0000000000
--- a/_archive/docs/0.3/docs/strings.md
+++ /dev/null
@@ -1,3399 +0,0 @@
-# Strings
-[[toc]]
-
-
-## Introduction
-
-Hypervel includes a variety of functions for manipulating string values. Many of these functions are used by the framework itself; however, you are free to use them in your own applications if you find them convenient.
-
-
-## Available Methods
-
-
-
-
-### Strings
-
-
-
-[\__](#method-__)
-[class_basename](#method-class-basename)
-[e](#method-e)
-[preg_replace_array](#method-preg-replace-array)
-[Str::after](#method-str-after)
-[Str::afterLast](#method-str-after-last)
-[Str::apa](#method-str-apa)
-[Str::ascii](#method-str-ascii)
-[Str::before](#method-str-before)
-[Str::beforeLast](#method-str-before-last)
-[Str::between](#method-str-between)
-[Str::betweenFirst](#method-str-between-first)
-[Str::camel](#method-camel-case)
-[Str::charAt](#method-char-at)
-[Str::chopStart](#method-str-chop-start)
-[Str::chopEnd](#method-str-chop-end)
-[Str::contains](#method-str-contains)
-[Str::containsAll](#method-str-contains-all)
-[Str::doesntContain](#method-str-doesnt-contain)
-[Str::endsWith](#method-ends-with)
-[Str::excerpt](#method-excerpt)
-[Str::finish](#method-str-finish)
-[Str::headline](#method-str-headline)
-[Str::is](#method-str-is)
-[Str::isAscii](#method-str-is-ascii)
-[Str::isJson](#method-str-is-json)
-[Str::isUlid](#method-str-is-ulid)
-[Str::isUrl](#method-str-is-url)
-[Str::isUuid](#method-str-is-uuid)
-[Str::kebab](#method-kebab-case)
-[Str::lcfirst](#method-str-lcfirst)
-[Str::length](#method-str-length)
-[Str::limit](#method-str-limit)
-[Str::lower](#method-str-lower)
-[Str::mask](#method-str-mask)
-[Str::orderedUuid](#method-str-ordered-uuid)
-[Str::padBoth](#method-str-padboth)
-[Str::padLeft](#method-str-padleft)
-[Str::padRight](#method-str-padright)
-[Str::password](#method-str-password)
-[Str::plural](#method-str-plural)
-[Str::pluralStudly](#method-str-plural-studly)
-[Str::position](#method-str-position)
-[Str::random](#method-str-random)
-[Str::remove](#method-str-remove)
-[Str::repeat](#method-str-repeat)
-[Str::replace](#method-str-replace)
-[Str::replaceArray](#method-str-replace-array)
-[Str::replaceFirst](#method-str-replace-first)
-[Str::replaceLast](#method-str-replace-last)
-[Str::replaceMatches](#method-str-replace-matches)
-[Str::replaceStart](#method-str-replace-start)
-[Str::replaceEnd](#method-str-replace-end)
-[Str::reverse](#method-str-reverse)
-[Str::singular](#method-str-singular)
-[Str::slug](#method-str-slug)
-[Str::snake](#method-snake-case)
-[Str::squish](#method-str-squish)
-[Str::start](#method-str-start)
-[Str::startsWith](#method-starts-with)
-[Str::studly](#method-studly-case)
-[Str::substr](#method-str-substr)
-[Str::substrCount](#method-str-substrcount)
-[Str::substrReplace](#method-str-substrreplace)
-[Str::swap](#method-str-swap)
-[Str::take](#method-take)
-[Str::title](#method-title-case)
-[Str::toBase64](#method-str-to-base64)
-[Str::trim](#method-str-trim)
-[Str::ltrim](#method-str-ltrim)
-[Str::rtrim](#method-str-rtrim)
-[Str::ucfirst](#method-str-ucfirst)
-[Str::ucsplit](#method-str-ucsplit)
-[Str::upper](#method-str-upper)
-[Str::ulid](#method-str-ulid)
-[Str::unwrap](#method-str-unwrap)
-[Str::uuid](#method-str-uuid)
-[Str::wordCount](#method-str-word-count)
-[Str::wordWrap](#method-str-word-wrap)
-[Str::words](#method-str-words)
-[Str::wrap](#method-str-wrap)
-[str](#method-str)
-[trans](#method-trans)
-[trans_choice](#method-trans-choice)
-
-
-
-
-### Fluent Strings
-
-
-
-[after](#method-fluent-str-after)
-[afterLast](#method-fluent-str-after-last)
-[apa](#method-fluent-str-apa)
-[append](#method-fluent-str-append)
-[ascii](#method-fluent-str-ascii)
-[basename](#method-fluent-str-basename)
-[before](#method-fluent-str-before)
-[beforeLast](#method-fluent-str-before-last)
-[between](#method-fluent-str-between)
-[betweenFirst](#method-fluent-str-between-first)
-[camel](#method-fluent-str-camel)
-[charAt](#method-fluent-str-char-at)
-[classBasename](#method-fluent-str-class-basename)
-[chopStart](#method-fluent-str-chop-start)
-[chopEnd](#method-fluent-str-chop-end)
-[contains](#method-fluent-str-contains)
-[containsAll](#method-fluent-str-contains-all)
-[dirname](#method-fluent-str-dirname)
-[endsWith](#method-fluent-str-ends-with)
-[exactly](#method-fluent-str-exactly)
-[excerpt](#method-fluent-str-excerpt)
-[explode](#method-fluent-str-explode)
-[finish](#method-fluent-str-finish)
-[headline](#method-fluent-str-headline)
-[is](#method-fluent-str-is)
-[isAscii](#method-fluent-str-is-ascii)
-[isEmpty](#method-fluent-str-is-empty)
-[isNotEmpty](#method-fluent-str-is-not-empty)
-[isJson](#method-fluent-str-is-json)
-[isUlid](#method-fluent-str-is-ulid)
-[isUrl](#method-fluent-str-is-url)
-[isUuid](#method-fluent-str-is-uuid)
-[kebab](#method-fluent-str-kebab)
-[lcfirst](#method-fluent-str-lcfirst)
-[length](#method-fluent-str-length)
-[limit](#method-fluent-str-limit)
-[lower](#method-fluent-str-lower)
-[mask](#method-fluent-str-mask)
-[match](#method-fluent-str-match)
-[matchAll](#method-fluent-str-match-all)
-[isMatch](#method-fluent-str-is-match)
-[newLine](#method-fluent-str-new-line)
-[padBoth](#method-fluent-str-padboth)
-[padLeft](#method-fluent-str-padleft)
-[padRight](#method-fluent-str-padright)
-[pipe](#method-fluent-str-pipe)
-[plural](#method-fluent-str-plural)
-[position](#method-fluent-str-position)
-[prepend](#method-fluent-str-prepend)
-[remove](#method-fluent-str-remove)
-[repeat](#method-fluent-str-repeat)
-[replace](#method-fluent-str-replace)
-[replaceArray](#method-fluent-str-replace-array)
-[replaceFirst](#method-fluent-str-replace-first)
-[replaceLast](#method-fluent-str-replace-last)
-[replaceMatches](#method-fluent-str-replace-matches)
-[replaceStart](#method-fluent-str-replace-start)
-[replaceEnd](#method-fluent-str-replace-end)
-[scan](#method-fluent-str-scan)
-[singular](#method-fluent-str-singular)
-[slug](#method-fluent-str-slug)
-[snake](#method-fluent-str-snake)
-[split](#method-fluent-str-split)
-[squish](#method-fluent-str-squish)
-[start](#method-fluent-str-start)
-[startsWith](#method-fluent-str-starts-with)
-[stripTags](#method-fluent-str-strip-tags)
-[studly](#method-fluent-str-studly)
-[substr](#method-fluent-str-substr)
-[substrReplace](#method-fluent-str-substrreplace)
-[swap](#method-fluent-str-swap)
-[take](#method-fluent-str-take)
-[tap](#method-fluent-str-tap)
-[test](#method-fluent-str-test)
-[title](#method-fluent-str-title)
-[toBase64](#method-fluent-str-to-base64)
-[trim](#method-fluent-str-trim)
-[ltrim](#method-fluent-str-ltrim)
-[rtrim](#method-fluent-str-rtrim)
-[ucfirst](#method-fluent-str-ucfirst)
-[ucsplit](#method-fluent-str-ucsplit)
-[unwrap](#method-fluent-str-unwrap)
-[upper](#method-fluent-str-upper)
-[when](#method-fluent-str-when)
-[whenContains](#method-fluent-str-when-contains)
-[whenContainsAll](#method-fluent-str-when-contains-all)
-[whenEmpty](#method-fluent-str-when-empty)
-[whenNotEmpty](#method-fluent-str-when-not-empty)
-[whenStartsWith](#method-fluent-str-when-starts-with)
-[whenEndsWith](#method-fluent-str-when-ends-with)
-[whenExactly](#method-fluent-str-when-exactly)
-[whenNotExactly](#method-fluent-str-when-not-exactly)
-[whenIs](#method-fluent-str-when-is)
-[whenIsAscii](#method-fluent-str-when-is-ascii)
-[whenIsUlid](#method-fluent-str-when-is-ulid)
-[whenIsUuid](#method-fluent-str-when-is-uuid)
-[whenTest](#method-fluent-str-when-test)
-[wordCount](#method-fluent-str-word-count)
-[words](#method-fluent-str-words)
-[wrap](#method-fluent-str-wrap)
-
-
-
-
-## Strings
-
-
-#### __()
-
-The `__` function translates the given translation string or translation key using your [language files](/docs/localization):
-
-```php
-echo __('Welcome to our application');
-
-echo __('messages.welcome');
-```
-
-If the specified translation string or key does not exist, the `__` function will return the given value. So, using the example above, the `__` function would return `messages.welcome` if that translation key does not exist.
-
-
-#### class_basename()
-
-The `class_basename` function returns the class name of the given class with the class's namespace removed:
-
-```php
-$class = class_basename('Foo\Bar\Baz');
-
-// Baz
-```
-
-
-#### e()
-
-The `e` function runs PHP's `htmlspecialchars` function with the `double_encode` option set to `true` by default:
-
-```php
-echo e('foo');
-
-// <html>foo</html>
-```
-
-
-#### preg_replace_array()
-
-The `preg_replace_array` function replaces a given pattern in the string sequentially using an array:
-
-```php
-$string = 'The event will take place between :start and :end';
-
-$replaced = preg_replace_array('/:[a-z_]+/', ['8:30', '9:00'], $string);
-
-// The event will take place between 8:30 and 9:00
-```
-
-
-#### Str::after()
-
-The `Str::after` method returns everything after the given value in a string. The entire string will be returned if the value does not exist within the string:
-
-```php
-use Hypervel\Support\Str;
-
-$slice = Str::after('This is my name', 'This is');
-
-// ' my name'
-```
-
-
-#### Str::afterLast()
-
-The `Str::afterLast` method returns everything after the last occurrence of the given value in a string. The entire string will be returned if the value does not exist within the string:
-
-```php
-use Hypervel\Support\Str;
-
-$slice = Str::afterLast('App\Http\Controllers\Controller', '\\');
-
-// 'Controller'
-```
-
-
-#### Str::apa()
-
-The `Str::apa` method converts the given string to title case following the [APA guidelines](https://apastyle.apa.org/style-grammar-guidelines/capitalization/title-case):
-
-```php
-use Hypervel\Support\Str;
-
-$title = Str::apa('Creating A Project');
-
-// 'Creating a Project'
-```
-
-
-#### Str::ascii()
-
-The `Str::ascii` method will attempt to transliterate the string into an ASCII value:
-
-```php
-use Hypervel\Support\Str;
-
-$slice = Str::ascii('û');
-
-// 'u'
-```
-
-
-#### Str::before()
-
-The `Str::before` method returns everything before the given value in a string:
-
-```php
-use Hypervel\Support\Str;
-
-$slice = Str::before('This is my name', 'my name');
-
-// 'This is '
-```
-
-
-#### Str::beforeLast()
-
-The `Str::beforeLast` method returns everything before the last occurrence of the given value in a string:
-
-```php
-use Hypervel\Support\Str;
-
-$slice = Str::beforeLast('This is my name', 'is');
-
-// 'This '
-```
-
-
-#### Str::between()
-
-The `Str::between` method returns the portion of a string between two values:
-
-```php
-use Hypervel\Support\Str;
-
-$slice = Str::between('This is my name', 'This', 'name');
-
-// ' is my '
-```
-
-
-#### Str::betweenFirst()
-
-The `Str::betweenFirst` method returns the smallest possible portion of a string between two values:
-
-```php
-use Hypervel\Support\Str;
-
-$slice = Str::betweenFirst('[a] bc [d]', '[', ']');
-
-// 'a'
-```
-
-
-#### Str::camel()
-
-The `Str::camel` method converts the given string to `camelCase`:
-
-```php
-use Hypervel\Support\Str;
-
-$converted = Str::camel('foo_bar');
-
-// 'fooBar'
-```
-
-
-#### Str::charAt()
-
-The `Str::charAt` method returns the character at the specified index. If the index is out of bounds, `false` is returned:
-
-```php
-use Hypervel\Support\Str;
-
-$character = Str::charAt('This is my name.', 6);
-
-// 's'
-```
-
-
-#### Str::chopStart()
-
-The `Str::chopStart` method removes the first occurrence of the given value only if the value appears at the start of the string:
-
-```php
-use Hypervel\Support\Str;
-
-$url = Str::chopStart('https://laravel.com', 'https://');
-
-// 'laravel.com'
-```
-
-You may also pass an array as the second argument. If the string starts with any of the values in the array then that value will be removed from string:
-
-```php
-use Hypervel\Support\Str;
-
-$url = Str::chopStart('http://laravel.com', ['https://', 'http://']);
-
-// 'laravel.com'
-```
-
-
-#### Str::chopEnd()
-
-The `Str::chopEnd` method removes the last occurrence of the given value only if the value appears at the end of the string:
-
-```php
-use Hypervel\Support\Str;
-
-$url = Str::chopEnd('app/Models/Photograph.php', '.php');
-
-// 'app/Models/Photograph'
-```
-
-You may also pass an array as the second argument. If the string ends with any of the values in the array then that value will be removed from string:
-
-```php
-use Hypervel\Support\Str;
-
-$url = Str::chopEnd('laravel.com/index.php', ['/index.html', '/index.php']);
-
-// 'laravel.com'
-```
-
-
-#### Str::contains()
-
-The `Str::contains` method determines if the given string contains the given value. By default this method is case sensitive:
-
-```php
-use Hypervel\Support\Str;
-
-$contains = Str::contains('This is my name', 'my');
-
-// true
-```
-
-You may also pass an array of values to determine if the given string contains any of the values in the array:
-
-```php
-use Hypervel\Support\Str;
-
-$contains = Str::contains('This is my name', ['my', 'foo']);
-
-// true
-```
-
-You may disable case sensitivity by setting the `ignoreCase` argument to `true`:
-
-```php
-use Hypervel\Support\Str;
-
-$contains = Str::contains('This is my name', 'MY', ignoreCase: true);
-
-// true
-```
-
-
-#### Str::containsAll()
-
-The `Str::containsAll` method determines if the given string contains all of the values in a given array:
-
-```php
-use Hypervel\Support\Str;
-
-$containsAll = Str::containsAll('This is my name', ['my', 'name']);
-
-// true
-```
-
-You may disable case sensitivity by setting the `ignoreCase` argument to `true`:
-
-```php
-use Hypervel\Support\Str;
-
-$containsAll = Str::containsAll('This is my name', ['MY', 'NAME'], ignoreCase: true);
-
-// true
-```
-
-
-#### Str::doesntContain()
-
-The `Str::doesntContain` method determines if the given string doesn't contain the given value. By default this method is case sensitive:
-
-```php
-use Hypervel\Support\Str;
-
-$doesntContain = Str::doesntContain('This is name', 'my');
-
-// true
-```
-
-You may also pass an array of values to determine if the given string doesn't contain any of the values in the array:
-
-```php
-use Hypervel\Support\Str;
-
-$doesntContain = Str::doesntContain('This is name', ['my', 'foo']);
-
-// true
-```
-
-You may disable case sensitivity by setting the `ignoreCase` argument to `true`:
-
-```php
-use Hypervel\Support\Str;
-
-$doesntContain = Str::doesntContain('This is name', 'MY', ignoreCase: true);
-
-// true
-```
-
-
-#### Str::endsWith()
-
-The `Str::endsWith` method determines if the given string ends with the given value:
-
-```php
-use Hypervel\Support\Str;
-
-$result = Str::endsWith('This is my name', 'name');
-
-// true
-```
-
-You may also pass an array of values to determine if the given string ends with any of the values in the array:
-
-```php
-use Hypervel\Support\Str;
-
-$result = Str::endsWith('This is my name', ['name', 'foo']);
-
-// true
-
-$result = Str::endsWith('This is my name', ['this', 'foo']);
-
-// false
-```
-
-
-#### Str::excerpt()
-
-The `Str::excerpt` method extracts an excerpt from a given string that matches the first instance of a phrase within that string:
-
-```php
-use Hypervel\Support\Str;
-
-$excerpt = Str::excerpt('This is my name', 'my', [
- 'radius' => 3
-]);
-
-// '...is my na...'
-```
-
-The `radius` option, which defaults to `100`, allows you to define the number of characters that should appear on each side of the truncated string.
-
-In addition, you may use the `omission` option to define the string that will be prepended and appended to the truncated string:
-
-```php
-use Hypervel\Support\Str;
-
-$excerpt = Str::excerpt('This is my name', 'name', [
- 'radius' => 3,
- 'omission' => '(...) '
-]);
-
-// '(...) my name'
-```
-
-
-#### Str::finish()
-
-The `Str::finish` method adds a single instance of the given value to a string if it does not already end with that value:
-
-```php
-use Hypervel\Support\Str;
-
-$adjusted = Str::finish('this/string', '/');
-
-// this/string/
-
-$adjusted = Str::finish('this/string/', '/');
-
-// this/string/
-```
-
-
-#### Str::headline()
-
-The `Str::headline` method will convert strings delimited by casing, hyphens, or underscores into a space delimited string with each word's first letter capitalized:
-
-```php
-use Hypervel\Support\Str;
-
-$headline = Str::headline('steve_jobs');
-
-// Steve Jobs
-
-$headline = Str::headline('EmailNotificationSent');
-
-// Email Notification Sent
-```
-
-
-#### Str::is()
-
-The `Str::is` method determines if a given string matches a given pattern. Asterisks may be used as wildcard values:
-
-```php
-use Hypervel\Support\Str;
-
-$matches = Str::is('foo*', 'foobar');
-
-// true
-
-$matches = Str::is('baz*', 'foobar');
-
-// false
-```
-
-You may disable case sensitivity by setting the `ignoreCase` argument to `true`:
-
-```php
-use Hypervel\Support\Str;
-
-$matches = Str::is('*.jpg', 'photo.JPG', ignoreCase: true);
-
-// true
-```
-
-
-#### Str::isAscii()
-
-The `Str::isAscii` method determines if a given string is 7 bit ASCII:
-
-```php
-use Hypervel\Support\Str;
-
-$isAscii = Str::isAscii('Taylor');
-
-// true
-
-$isAscii = Str::isAscii('ü');
-
-// false
-```
-
-
-#### Str::isJson()
-
-The `Str::isJson` method determines if the given string is valid JSON:
-
-```php
-use Hypervel\Support\Str;
-
-$result = Str::isJson('[1,2,3]');
-
-// true
-
-$result = Str::isJson('{"first": "John", "last": "Doe"}');
-
-// true
-
-$result = Str::isJson('{first: "John", last: "Doe"}');
-
-// false
-```
-
-
-#### Str::isUrl()
-
-The `Str::isUrl` method determines if the given string is a valid URL:
-
-```php
-use Hypervel\Support\Str;
-
-$isUrl = Str::isUrl('http://example.com');
-
-// true
-
-$isUrl = Str::isUrl('laravel');
-
-// false
-```
-
-The `isUrl` method considers a wide range of protocols as valid. However, you may specify the protocols that should be considered valid by providing them to the `isUrl` method:
-
-```php
-$isUrl = Str::isUrl('http://example.com', ['http', 'https']);
-```
-
-
-#### Str::isUlid()
-
-The `Str::isUlid` method determines if the given string is a valid ULID:
-
-```php
-use Hypervel\Support\Str;
-
-$isUlid = Str::isUlid('01gd6r360bp37zj17nxb55yv40');
-
-// true
-
-$isUlid = Str::isUlid('laravel');
-
-// false
-```
-
-
-#### Str::isUuid()
-
-The `Str::isUuid` method determines if the given string is a valid UUID:
-
-```php
-use Hypervel\Support\Str;
-
-$isUuid = Str::isUuid('a0a2a2d2-0b87-4a18-83f2-2529882be2de');
-
-// true
-
-$isUuid = Str::isUuid('laravel');
-
-// false
-```
-
-
-#### Str::kebab()
-
-The `Str::kebab` method converts the given string to `kebab-case`:
-
-```php
-use Hypervel\Support\Str;
-
-$converted = Str::kebab('fooBar');
-
-// foo-bar
-```
-
-
-#### Str::lcfirst()
-
-The `Str::lcfirst` method returns the given string with the first character lowercased:
-
-```php
-use Hypervel\Support\Str;
-
-$string = Str::lcfirst('Foo Bar');
-
-// foo Bar
-```
-
-
-#### Str::length()
-
-The `Str::length` method returns the length of the given string:
-
-```php
-use Hypervel\Support\Str;
-
-$length = Str::length('Laravel');
-
-// 7
-```
-
-
-#### Str::limit()
-
-The `Str::limit` method truncates the given string to the specified length:
-
-```php
-use Hypervel\Support\Str;
-
-$truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20);
-
-// The quick brown fox...
-```
-
-You may pass a third argument to the method to change the string that will be appended to the end of the truncated string:
-
-```php
-$truncated = Str::limit('The quick brown fox jumps over the lazy dog', 20, ' (...)');
-
-// The quick brown fox (...)
-```
-
-If you would like to preserve complete words when truncating the string, you may utilize the `preserveWords` argument. When this argument is `true`, the string will be truncated to the nearest complete word boundary:
-
-```php
-$truncated = Str::limit('The quick brown fox', 12, preserveWords: true);
-
-// The quick...
-```
-
-
-#### Str::lower()
-
-The `Str::lower` method converts the given string to lowercase:
-
-```php
-use Hypervel\Support\Str;
-
-$converted = Str::lower('LARAVEL');
-
-// laravel
-```
-
-
-#### Str::mask()
-
-The `Str::mask` method masks a portion of a string with a repeated character, and may be used to obfuscate segments of strings such as email addresses and phone numbers:
-
-```php
-use Hypervel\Support\Str;
-
-$string = Str::mask('taylor@example.com', '*', 3);
-
-// tay***************
-```
-
-If needed, you provide a negative number as the third argument to the `mask` method, which will instruct the method to begin masking at the given distance from the end of the string:
-
-```php
-$string = Str::mask('taylor@example.com', '*', -15, 3);
-
-// tay***@example.com
-```
-
-
-#### Str::orderedUuid()
-
-The `Str::orderedUuid` method generates a "timestamp first" UUID that may be efficiently stored in an indexed database column. Each UUID that is generated using this method will be sorted after UUIDs previously generated using the method:
-
-```php
-use Hypervel\Support\Str;
-
-return (string) Str::orderedUuid();
-```
-
-
-#### Str::padBoth()
-
-The `Str::padBoth` method wraps PHP's `str_pad` function, padding both sides of a string with another string until the final string reaches a desired length:
-
-```php
-use Hypervel\Support\Str;
-
-$padded = Str::padBoth('James', 10, '_');
-
-// '__James___'
-
-$padded = Str::padBoth('James', 10);
-
-// ' James '
-```
-
-
-#### Str::padLeft()
-
-The `Str::padLeft` method wraps PHP's `str_pad` function, padding the left side of a string with another string until the final string reaches a desired length:
-
-```php
-use Hypervel\Support\Str;
-
-$padded = Str::padLeft('James', 10, '-=');
-
-// '-=-=-James'
-
-$padded = Str::padLeft('James', 10);
-
-// ' James'
-```
-
-
-#### Str::padRight()
-
-The `Str::padRight` method wraps PHP's `str_pad` function, padding the right side of a string with another string until the final string reaches a desired length:
-
-```php
-use Hypervel\Support\Str;
-
-$padded = Str::padRight('James', 10, '-');
-
-// 'James-----'
-
-$padded = Str::padRight('James', 10);
-
-// 'James '
-```
-
-
-#### Str::password()
-
-The `Str::password` method may be used to generate a secure, random password of a given length. The password will consist of a combination of letters, numbers, symbols, and spaces. By default, passwords are 32 characters long:
-
-```php
-use Hypervel\Support\Str;
-
-$password = Str::password();
-
-// 'EbJo2vE-AS:U,$%_gkrV4n,q~1xy/-_4'
-
-$password = Str::password(12);
-
-// 'qwuar>#V|i]N'
-```
-
-
-#### Str::plural()
-
-The `Str::plural` method converts a singular word string to its plural form. This function supports [any of the languages support by Laravel's pluralizer](/docs/localization#pluralization-language):
-
-```php
-use Hypervel\Support\Str;
-
-$plural = Str::plural('car');
-
-// cars
-
-$plural = Str::plural('child');
-
-// children
-```
-
-You may provide an integer as a second argument to the function to retrieve the singular or plural form of the string:
-
-```php
-use Hypervel\Support\Str;
-
-$plural = Str::plural('child', 2);
-
-// children
-
-$singular = Str::plural('child', 1);
-
-// child
-```
-
-
-#### Str::pluralStudly()
-
-The `Str::pluralStudly` method converts a singular word string formatted in studly caps case to its plural form. This function supports [any of the languages support by Laravel's pluralizer](/docs/localization#pluralization-language):
-
-```php
-use Hypervel\Support\Str;
-
-$plural = Str::pluralStudly('VerifiedHuman');
-
-// VerifiedHumans
-
-$plural = Str::pluralStudly('UserFeedback');
-
-// UserFeedback
-```
-
-You may provide an integer as a second argument to the function to retrieve the singular or plural form of the string:
-
-```php
-use Hypervel\Support\Str;
-
-$plural = Str::pluralStudly('VerifiedHuman', 2);
-
-// VerifiedHumans
-
-$singular = Str::pluralStudly('VerifiedHuman', 1);
-
-// VerifiedHuman
-```
-
-
-#### Str::position()
-
-The `Str::position` method returns the position of the first occurrence of a substring in a string. If the substring does not exist in the given string, `false` is returned:
-
-```php
-use Hypervel\Support\Str;
-
-$position = Str::position('Hello, World!', 'Hello');
-
-// 0
-
-$position = Str::position('Hello, World!', 'W');
-
-// 7
-```
-
-
-#### Str::random()
-
-The `Str::random` method generates a random string of the specified length. This function uses PHP's `random_bytes` function:
-
-```php
-use Hypervel\Support\Str;
-
-$random = Str::random(40);
-```
-
-During testing, it may be useful to "fake" the value that is returned by the `Str::random` method. To accomplish this, you may use the `createRandomStringsUsing` method:
-
-```php
-Str::createRandomStringsUsing(function () {
- return 'fake-random-string';
-});
-```
-
-To instruct the `random` method to return to generating random strings normally, you may invoke the `createRandomStringsNormally` method:
-
-```php
-Str::createRandomStringsNormally();
-```
-
-
-#### Str::remove()
-
-The `Str::remove` method removes the given value or array of values from the string:
-
-```php
-use Hypervel\Support\Str;
-
-$string = 'Peter Piper picked a peck of pickled peppers.';
-
-$removed = Str::remove('e', $string);
-
-// Ptr Pipr pickd a pck of pickld ppprs.
-```
-
-You may also pass `false` as a third argument to the `remove` method to ignore case when removing strings.
-
-
-#### Str::repeat()
-
-The `Str::repeat` method repeats the given string:
-
-```php
-use Hypervel\Support\Str;
-
-$string = 'a';
-
-$repeat = Str::repeat($string, 5);
-
-// aaaaa
-```
-
-
-#### Str::replace()
-
-The `Str::replace` method replaces a given string within the string:
-
-```php
-use Hypervel\Support\Str;
-
-$string = 'Laravel 11.x';
-
-$replaced = Str::replace('11.x', '12.x', $string);
-
-// Laravel 12.x
-```
-
-The `replace` method also accepts a `caseSensitive` argument. By default, the `replace` method is case sensitive:
-
-```php
-Str::replace('Framework', 'Laravel', caseSensitive: false);
-```
-
-
-#### Str::replaceArray()
-
-The `Str::replaceArray` method replaces a given value in the string sequentially using an array:
-
-```php
-use Hypervel\Support\Str;
-
-$string = 'The event will take place between ? and ?';
-
-$replaced = Str::replaceArray('?', ['8:30', '9:00'], $string);
-
-// The event will take place between 8:30 and 9:00
-```
-
-
-#### Str::replaceFirst()
-
-The `Str::replaceFirst` method replaces the first occurrence of a given value in a string:
-
-```php
-use Hypervel\Support\Str;
-
-$replaced = Str::replaceFirst('the', 'a', 'the quick brown fox jumps over the lazy dog');
-
-// a quick brown fox jumps over the lazy dog
-```
-
-
-#### Str::replaceLast()
-
-The `Str::replaceLast` method replaces the last occurrence of a given value in a string:
-
-```php
-use Hypervel\Support\Str;
-
-$replaced = Str::replaceLast('the', 'a', 'the quick brown fox jumps over the lazy dog');
-
-// the quick brown fox jumps over a lazy dog
-```
-
-
-#### Str::replaceMatches()
-
-The `Str::replaceMatches` method replaces all portions of a string matching a pattern with the given replacement string:
-
-```php
-use Hypervel\Support\Str;
-
-$replaced = Str::replaceMatches(
- pattern: '/[^A-Za-z0-9]++/',
- replace: '',
- subject: '(+1) 501-555-1000'
-)
-
-// '15015551000'
-```
-
-The `replaceMatches` method also accepts a closure that will be invoked with each portion of the string matching the given pattern, allowing you to perform the replacement logic within the closure and return the replaced value:
-
-```php
-use Hypervel\Support\Str;
-
-$replaced = Str::replaceMatches('/\d/', function (array $matches) {
- return '['.$matches[0].']';
-}, '123');
-
-// '[1][2][3]'
-```
-
-
-#### Str::replaceStart()
-
-The `Str::replaceStart` method replaces the first occurrence of the given value only if the value appears at the start of the string:
-
-```php
-use Hypervel\Support\Str;
-
-$replaced = Str::replaceStart('Hello', 'Laravel', 'Hello World');
-
-// Laravel World
-
-$replaced = Str::replaceStart('World', 'Laravel', 'Hello World');
-
-// Hello World
-```
-
-
-#### Str::replaceEnd()
-
-The `Str::replaceEnd` method replaces the last occurrence of the given value only if the value appears at the end of the string:
-
-```php
-use Hypervel\Support\Str;
-
-$replaced = Str::replaceEnd('World', 'Laravel', 'Hello World');
-
-// Hello Laravel
-
-$replaced = Str::replaceEnd('Hello', 'Laravel', 'Hello World');
-
-// Hello World
-```
-
-
-#### Str::reverse()
-
-The `Str::reverse` method reverses the given string:
-
-```php
-use Hypervel\Support\Str;
-
-$reversed = Str::reverse('Hello World');
-
-// dlroW olleH
-```
-
-
-#### Str::singular()
-
-The `Str::singular` method converts a string to its singular form. This function supports [any of the languages support by Laravel's pluralizer](/docs/localization#pluralization-language):
-
-```php
-use Hypervel\Support\Str;
-
-$singular = Str::singular('cars');
-
-// car
-
-$singular = Str::singular('children');
-
-// child
-```
-
-
-#### Str::slug()
-
-The `Str::slug` method generates a URL friendly "slug" from the given string:
-
-```php
-use Hypervel\Support\Str;
-
-$slug = Str::slug('Laravel 5 Framework', '-');
-
-// laravel-5-framework
-```
-
-
-#### Str::snake()
-
-The `Str::snake` method converts the given string to `snake_case`:
-
-```php
-use Hypervel\Support\Str;
-
-$converted = Str::snake('fooBar');
-
-// foo_bar
-
-$converted = Str::snake('fooBar', '-');
-
-// foo-bar
-```
-
-
-#### Str::squish()
-
-The `Str::squish` method removes all extraneous white space from a string, including extraneous white space between words:
-
-```php
-use Hypervel\Support\Str;
-
-$string = Str::squish(' Hypervel framework ');
-
-// Hypervel framework
-```
-
-
-#### Str::start()
-
-The `Str::start` method adds a single instance of the given value to a string if it does not already start with that value:
-
-```php
-use Hypervel\Support\Str;
-
-$adjusted = Str::start('this/string', '/');
-
-// /this/string
-
-$adjusted = Str::start('/this/string', '/');
-
-// /this/string
-```
-
-
-#### Str::startsWith()
-
-The `Str::startsWith` method determines if the given string begins with the given value:
-
-```php
-use Hypervel\Support\Str;
-
-$result = Str::startsWith('This is my name', 'This');
-
-// true
-```
-
-If an array of possible values is passed, the `startsWith` method will return `true` if the string begins with any of the given values:
-
-```php
-$result = Str::startsWith('This is my name', ['This', 'That', 'There']);
-
-// true
-```
-
-
-#### Str::studly()
-
-The `Str::studly` method converts the given string to `StudlyCase`:
-
-```php
-use Hypervel\Support\Str;
-
-$converted = Str::studly('foo_bar');
-
-// FooBar
-```
-
-
-#### Str::substr()
-
-The `Str::substr` method returns the portion of string specified by the start and length parameters:
-
-```php
-use Hypervel\Support\Str;
-
-$converted = Str::substr('The Laravel Framework', 4, 7);
-
-// Laravel
-```
-
-
-#### Str::substrCount()
-
-The `Str::substrCount` method returns the number of occurrences of a given value in the given string:
-
-```php
-use Hypervel\Support\Str;
-
-$count = Str::substrCount('If you like ice cream, you will like snow cones.', 'like');
-
-// 2
-```
-
-
-#### Str::substrReplace()
-
-The `Str::substrReplace` method replaces text within a portion of a string, starting at the position specified by the third argument and replacing the number of characters specified by the fourth argument. Passing `0` to the method's fourth argument will insert the string at the specified position without replacing any of the existing characters in the string:
-
-```php
-use Hypervel\Support\Str;
-
-$result = Str::substrReplace('1300', ':', 2);
-// 13:
-
-$result = Str::substrReplace('1300', ':', 2, 0);
-// 13:00
-```
-
-
-#### Str::swap()
-
-The `Str::swap` method replaces multiple values in the given string using PHP's `strtr` function:
-
-```php
-use Hypervel\Support\Str;
-
-$string = Str::swap([
- 'Tacos' => 'Burritos',
- 'great' => 'fantastic',
-], 'Tacos are great!');
-
-// Burritos are fantastic!
-```
-
-
-#### Str::take()
-
-The `Str::take` method returns a specified number of characters from the beginning of a string:
-
-```php
-use Hypervel\Support\Str;
-
-$taken = Str::take('Build something amazing!', 5);
-
-// Build
-```
-
-
-#### Str::title()
-
-The `Str::title` method converts the given string to `Title Case`:
-
-```php
-use Hypervel\Support\Str;
-
-$converted = Str::title('a nice title uses the correct case');
-
-// A Nice Title Uses The Correct Case
-```
-
-
-#### Str::toBase64()
-
-The `Str::toBase64` method converts the given string to Base64:
-
-```php
-use Hypervel\Support\Str;
-
-$base64 = Str::toBase64('Laravel');
-
-// TGFyYXZlbA==
-```
-
-
-#### Str::trim()
-
-The `Str::trim` method strips whitespace (or other characters) from the beginning and end of the given string. Unlike PHP's native `trim` function, the `Str::trim` method also removes unicode whitespace characters:
-
-```php
-use Hypervel\Support\Str;
-
-$string = Str::trim(' foo bar ');
-
-// 'foo bar'
-```
-
-
-#### Str::ltrim()
-
-The `Str::ltrim` method strips whitespace (or other characters) from the beginning of the given string. Unlike PHP's native `ltrim` function, the `Str::ltrim` method also removes unicode whitespace characters:
-
-```php
-use Hypervel\Support\Str;
-
-$string = Str::ltrim(' foo bar ');
-
-// 'foo bar '
-```
-
-
-#### Str::rtrim()
-
-The `Str::rtrim` method strips whitespace (or other characters) from the end of the given string. Unlike PHP's native `rtrim` function, the `Str::rtrim` method also removes unicode whitespace characters:
-
-```php
-use Hypervel\Support\Str;
-
-$string = Str::rtrim(' foo bar ');
-
-// ' foo bar'
-```
-
-
-#### Str::ucfirst()
-
-The `Str::ucfirst` method returns the given string with the first character capitalized:
-
-```php
-use Hypervel\Support\Str;
-
-$string = Str::ucfirst('foo bar');
-
-// Foo bar
-```
-
-
-#### Str::ucsplit()
-
-The `Str::ucsplit` method splits the given string into an array by uppercase characters:
-
-```php
-use Hypervel\Support\Str;
-
-$segments = Str::ucsplit('FooBar');
-
-// [0 => 'Foo', 1 => 'Bar']
-```
-
-
-#### Str::upper()
-
-The `Str::upper` method converts the given string to uppercase:
-
-```php
-use Hypervel\Support\Str;
-
-$string = Str::upper('laravel');
-
-// LARAVEL
-```
-
-
-#### Str::ulid()
-
-The `Str::ulid` method generates a ULID, which is a compact, time-ordered unique identifier:
-
-```php
-use Hypervel\Support\Str;
-
-return (string) Str::ulid();
-
-// 01gd6r360bp37zj17nxb55yv40
-```
-
-If you would like to retrieve a `Hypervel\Support\Carbon` date instance representing the date and time that a given ULID was created, you may use the `createFromId` method provided by Laravel's Carbon integration:
-
-```php
-use Hypervel\Support\Carbon;
-use Hypervel\Support\Str;
-
-$date = Carbon::createFromId((string) Str::ulid());
-```
-
-During testing, it may be useful to "fake" the value that is returned by the `Str::ulid` method. To accomplish this, you may use the `createUlidsUsing` method:
-
-```php
-use Symfony\Component\Uid\Ulid;
-
-Str::createUlidsUsing(function () {
- return new Ulid('01HRDBNHHCKNW2AK4Z29SN82T9');
-});
-```
-
-To instruct the `ulid` method to return to generating ULIDs normally, you may invoke the `createUlidsNormally` method:
-
-```php
-Str::createUlidsNormally();
-```
-
-
-#### Str::unwrap()
-
-The `Str::unwrap` method removes the specified strings from the beginning and end of a given string:
-
-```php
-use Hypervel\Support\Str;
-
-Str::unwrap('-Laravel-', '-');
-
-// Laravel
-
-Str::unwrap('{framework: "Laravel"}', '{', '}');
-
-// framework: "Laravel"
-```
-
-
-#### Str::uuid()
-
-The `Str::uuid` method generates a UUID (version 4):
-
-```php
-use Hypervel\Support\Str;
-
-return (string) Str::uuid();
-```
-
-During testing, it may be useful to "fake" the value that is returned by the `Str::uuid` method. To accomplish this, you may use the `createUuidsUsing` method:
-
-```php
-use Ramsey\Uuid\Uuid;
-
-Str::createUuidsUsing(function () {
- return Uuid::fromString('eadbfeac-5258-45c2-bab7-ccb9b5ef74f9');
-});
-```
-
-To instruct the `uuid` method to return to generating UUIDs normally, you may invoke the `createUuidsNormally` method:
-
-```php
-Str::createUuidsNormally();
-```
-
-
-#### Str::wordCount()
-
-The `Str::wordCount` method returns the number of words that a string contains:
-
-```php
-use Hypervel\Support\Str;
-
-Str::wordCount('Hello, world!'); // 2
-```
-
-
-#### Str::wordWrap()
-
-The `Str::wordWrap` method wraps a string to a given number of characters:
-
-```php
-use Hypervel\Support\Str;
-
-$text = "The quick brown fox jumped over the lazy dog."
-
-Str::wordWrap($text, characters: 20, break: "\n"); - -/* -The quick brown fox
-jumped over the lazy
-dog. -*/ -``` - - -#### Str::words() - -The `Str::words` method limits the number of words in a string. An additional string may be passed to this method via its third argument to specify which string should be appended to the end of the truncated string: - -```php -use Hypervel\Support\Str; - -return Str::words('Perfectly balanced, as all things should be.', 3, ' >>>'); - -// Perfectly balanced, as >>> -``` - - -#### Str::wrap() - -The `Str::wrap` method wraps the given string with an additional string or pair of strings: - -```php -use Hypervel\Support\Str; - -Str::wrap('Laravel', '"'); - -// "Laravel" - -Str::wrap('is', before: 'This ', after: ' Laravel!'); - -// This is Laravel! -``` - - -#### str() - -The `str` function returns a new `Hypervel\Support\Stringable` instance of the given string. This function is equivalent to the `Str::of` method: - -```php -$string = str('Taylor')->append(' Otwell'); - -// 'Taylor Otwell' -``` - -If no argument is provided to the `str` function, the function returns an instance of `Hypervel\Support\Str`: - -```php -$snake = str()->snake('FooBar'); - -// 'foo_bar' -``` - - -#### trans() - -The `trans` function translates the given translation key using your [language files](/docs/localization): - -```php -echo trans('messages.welcome'); -``` - -If the specified translation key does not exist, the `trans` function will return the given key. So, using the example above, the `trans` function would return `messages.welcome` if the translation key does not exist. - - -#### trans_choice() - -The `trans_choice` function translates the given translation key with inflection: - -```php -echo trans_choice('messages.notifications', $unreadCount); -``` - -If the specified translation key does not exist, the `trans_choice` function will return the given key. So, using the example above, the `trans_choice` function would return `messages.notifications` if the translation key does not exist. - - -## Fluent Strings - -Fluent strings provide a more fluent, object-oriented interface for working with string values, allowing you to chain multiple string operations together using a more readable syntax compared to traditional string operations. - - -#### after - -The `after` method returns everything after the given value in a string. The entire string will be returned if the value does not exist within the string: - -```php -use Hypervel\Support\Str; - -$slice = Str::of('This is my name')->after('This is'); - -// ' my name' -``` - - -#### afterLast - -The `afterLast` method returns everything after the last occurrence of the given value in a string. The entire string will be returned if the value does not exist within the string: - -```php -use Hypervel\Support\Str; - -$slice = Str::of('App\Http\Controllers\Controller')->afterLast('\\'); - -// 'Controller' -``` - - -#### apa - -The `apa` method converts the given string to title case following the [APA guidelines](https://apastyle.apa.org/style-grammar-guidelines/capitalization/title-case): - -```php -use Hypervel\Support\Str; - -$converted = Str::of('a nice title uses the correct case')->apa(); - -// A Nice Title Uses the Correct Case -``` - - -#### append - -The `append` method appends the given values to the string: - -```php -use Hypervel\Support\Str; - -$string = Str::of('Taylor')->append(' Otwell'); - -// 'Taylor Otwell' -``` - - -#### ascii - -The `ascii` method will attempt to transliterate the string into an ASCII value: - -```php -use Hypervel\Support\Str; - -$string = Str::of('ü')->ascii(); - -// 'u' -``` - - -#### basename - -The `basename` method will return the trailing name component of the given string: - -```php -use Hypervel\Support\Str; - -$string = Str::of('/foo/bar/baz')->basename(); - -// 'baz' -``` - -If needed, you may provide an "extension" that will be removed from the trailing component: - -```php -use Hypervel\Support\Str; - -$string = Str::of('/foo/bar/baz.jpg')->basename('.jpg'); - -// 'baz' -``` - - -#### before - -The `before` method returns everything before the given value in a string: - -```php -use Hypervel\Support\Str; - -$slice = Str::of('This is my name')->before('my name'); - -// 'This is ' -``` - - -#### beforeLast - -The `beforeLast` method returns everything before the last occurrence of the given value in a string: - -```php -use Hypervel\Support\Str; - -$slice = Str::of('This is my name')->beforeLast('is'); - -// 'This ' -``` - - -#### between - -The `between` method returns the portion of a string between two values: - -```php -use Hypervel\Support\Str; - -$converted = Str::of('This is my name')->between('This', 'name'); - -// ' is my ' -``` - - -#### betweenFirst - -The `betweenFirst` method returns the smallest possible portion of a string between two values: - -```php -use Hypervel\Support\Str; - -$converted = Str::of('[a] bc [d]')->betweenFirst('[', ']'); - -// 'a' -``` - - -#### camel - -The `camel` method converts the given string to `camelCase`: - -```php -use Hypervel\Support\Str; - -$converted = Str::of('foo_bar')->camel(); - -// 'fooBar' -``` - - -#### charAt - -The `charAt` method returns the character at the specified index. If the index is out of bounds, `false` is returned: - -```php -use Hypervel\Support\Str; - -$character = Str::of('This is my name.')->charAt(6); - -// 's' -``` - - -#### classBasename - -The `classBasename` method returns the class name of the given class with the class's namespace removed: - -```php -use Hypervel\Support\Str; - -$class = Str::of('Foo\Bar\Baz')->classBasename(); - -// 'Baz' -``` - - -#### chopStart - -The `chopStart` method removes the first occurrence of the given value only if the value appears at the start of the string: - -```php -use Hypervel\Support\Str; - -$url = Str::of('https://laravel.com')->chopStart('https://'); - -// 'laravel.com' -``` - -You may also pass an array. If the string starts with any of the values in the array then that value will be removed from string: - -```php -use Hypervel\Support\Str; - -$url = Str::of('http://laravel.com')->chopStart(['https://', 'http://']); - -// 'laravel.com' -``` - - -#### chopEnd - -The `chopEnd` method removes the last occurrence of the given value only if the value appears at the end of the string: - -```php -use Hypervel\Support\Str; - -$url = Str::of('https://laravel.com')->chopEnd('.com'); - -// 'https://laravel' -``` - -You may also pass an array. If the string ends with any of the values in the array then that value will be removed from string: - -```php -use Hypervel\Support\Str; - -$url = Str::of('http://laravel.com')->chopEnd(['.com', '.io']); - -// 'http://laravel' -``` - - -#### contains - -The `contains` method determines if the given string contains the given value. By default this method is case sensitive: - -```php -use Hypervel\Support\Str; - -$contains = Str::of('This is my name')->contains('my'); - -// true -``` - -You may also pass an array of values to determine if the given string contains any of the values in the array: - -```php -use Hypervel\Support\Str; - -$contains = Str::of('This is my name')->contains(['my', 'foo']); - -// true -``` - -You can disable case sensitivity by setting the `ignoreCase` argument to `true`: - -```php -use Hypervel\Support\Str; - -$contains = Str::of('This is my name')->contains('MY', ignoreCase: true); - -// true -``` - - -#### containsAll - -The `containsAll` method determines if the given string contains all of the values in the given array: - -```php -use Hypervel\Support\Str; - -$containsAll = Str::of('This is my name')->containsAll(['my', 'name']); - -// true -``` - -You can disable case sensitivity by setting the `ignoreCase` argument to `true`: - -```php -use Hypervel\Support\Str; - -$containsAll = Str::of('This is my name')->containsAll(['MY', 'NAME'], ignoreCase: true); - -// true -``` - - -#### dirname - -The `dirname` method returns the parent directory portion of the given string: - -```php -use Hypervel\Support\Str; - -$string = Str::of('/foo/bar/baz')->dirname(); - -// '/foo/bar' -``` - -If necessary, you may specify how many directory levels you wish to trim from the string: - -```php -use Hypervel\Support\Str; - -$string = Str::of('/foo/bar/baz')->dirname(2); - -// '/foo' -``` - - -#### endsWith - -The `endsWith` method determines if the given string ends with the given value: - -```php -use Hypervel\Support\Str; - -$result = Str::of('This is my name')->endsWith('name'); - -// true -``` - -You may also pass an array of values to determine if the given string ends with any of the values in the array: - -```php -use Hypervel\Support\Str; - -$result = Str::of('This is my name')->endsWith(['name', 'foo']); - -// true - -$result = Str::of('This is my name')->endsWith(['this', 'foo']); - -// false -``` - - -#### exactly - -The `exactly` method determines if the given string is an exact match with another string: - -```php -use Hypervel\Support\Str; - -$result = Str::of('Laravel')->exactly('Laravel'); - -// true -``` - - -#### excerpt - -The `excerpt` method extracts an excerpt from the string that matches the first instance of a phrase within that string: - -```php -use Hypervel\Support\Str; - -$excerpt = Str::of('This is my name')->excerpt('my', [ - 'radius' => 3 -]); - -// '...is my na...' -``` - -The `radius` option, which defaults to `100`, allows you to define the number of characters that should appear on each side of the truncated string. - -In addition, you may use the `omission` option to change the string that will be prepended and appended to the truncated string: - -```php -use Hypervel\Support\Str; - -$excerpt = Str::of('This is my name')->excerpt('name', [ - 'radius' => 3, - 'omission' => '(...) ' -]); - -// '(...) my name' -``` - - -#### explode - -The `explode` method splits the string by the given delimiter and returns a collection containing each section of the split string: - -```php -use Hypervel\Support\Str; - -$collection = Str::of('foo bar baz')->explode(' '); - -// collect(['foo', 'bar', 'baz']) -``` - - -#### finish - -The `finish` method adds a single instance of the given value to a string if it does not already end with that value: - -```php -use Hypervel\Support\Str; - -$adjusted = Str::of('this/string')->finish('/'); - -// this/string/ - -$adjusted = Str::of('this/string/')->finish('/'); - -// this/string/ -``` - - -#### headline - -The `headline` method will convert strings delimited by casing, hyphens, or underscores into a space delimited string with each word's first letter capitalized: - -```php -use Hypervel\Support\Str; - -$headline = Str::of('taylor_otwell')->headline(); - -// Taylor Otwell - -$headline = Str::of('EmailNotificationSent')->headline(); - -// Email Notification Sent -``` - - -#### is - -The `is` method determines if a given string matches a given pattern. Asterisks may be used as wildcard values - -```php -use Hypervel\Support\Str; - -$matches = Str::of('foobar')->is('foo*'); - -// true - -$matches = Str::of('foobar')->is('baz*'); - -// false -``` - - -#### isAscii - -The `isAscii` method determines if a given string is an ASCII string: - -```php -use Hypervel\Support\Str; - -$result = Str::of('Taylor')->isAscii(); - -// true - -$result = Str::of('ü')->isAscii(); - -// false -``` - - -#### isEmpty - -The `isEmpty` method determines if the given string is empty: - -```php -use Hypervel\Support\Str; - -$result = Str::of(' ')->trim()->isEmpty(); - -// true - -$result = Str::of('Laravel')->trim()->isEmpty(); - -// false -``` - - -#### isNotEmpty - -The `isNotEmpty` method determines if the given string is not empty: - -```php -use Hypervel\Support\Str; - -$result = Str::of(' ')->trim()->isNotEmpty(); - -// false - -$result = Str::of('Laravel')->trim()->isNotEmpty(); - -// true -``` - - -#### isJson - -The `isJson` method determines if a given string is valid JSON: - -```php -use Hypervel\Support\Str; - -$result = Str::of('[1,2,3]')->isJson(); - -// true - -$result = Str::of('{"first": "John", "last": "Doe"}')->isJson(); - -// true - -$result = Str::of('{first: "John", last: "Doe"}')->isJson(); - -// false -``` - - -#### isUlid - -The `isUlid` method determines if a given string is a ULID: - -```php -use Hypervel\Support\Str; - -$result = Str::of('01gd6r360bp37zj17nxb55yv40')->isUlid(); - -// true - -$result = Str::of('Taylor')->isUlid(); - -// false -``` - - -#### isUrl - -The `isUrl` method determines if a given string is a URL: - -```php -use Hypervel\Support\Str; - -$result = Str::of('http://example.com')->isUrl(); - -// true - -$result = Str::of('Taylor')->isUrl(); - -// false -``` - -The `isUrl` method considers a wide range of protocols as valid. However, you may specify the protocols that should be considered valid by providing them to the `isUrl` method: - -```php -$result = Str::of('http://example.com')->isUrl(['http', 'https']); -``` - - -#### isUuid - -The `isUuid` method determines if a given string is a UUID: - -```php -use Hypervel\Support\Str; - -$result = Str::of('5ace9ab9-e9cf-4ec6-a19d-5881212a452c')->isUuid(); - -// true - -$result = Str::of('Taylor')->isUuid(); - -// false -``` - - -#### kebab - -The `kebab` method converts the given string to `kebab-case`: - -```php -use Hypervel\Support\Str; - -$converted = Str::of('fooBar')->kebab(); - -// foo-bar -``` - - -#### lcfirst - -The `lcfirst` method returns the given string with the first character lowercased: - -```php -use Hypervel\Support\Str; - -$string = Str::of('Foo Bar')->lcfirst(); - -// foo Bar -``` - - -#### length - -The `length` method returns the length of the given string: - -```php -use Hypervel\Support\Str; - -$length = Str::of('Laravel')->length(); - -// 7 -``` - - -#### limit - -The `limit` method truncates the given string to the specified length: - -```php -use Hypervel\Support\Str; - -$truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20); - -// The quick brown fox... -``` - -You may also pass a second argument to change the string that will be appended to the end of the truncated string: - -```php -$truncated = Str::of('The quick brown fox jumps over the lazy dog')->limit(20, ' (...)'); - -// The quick brown fox (...) -``` - -If you would like to preserve complete words when truncating the string, you may utilize the `preserveWords` argument. When this argument is `true`, the string will be truncated to the nearest complete word boundary: - -```php -$truncated = Str::of('The quick brown fox')->limit(12, preserveWords: true); - -// The quick... -``` - - -#### lower - -The `lower` method converts the given string to lowercase: - -```php -use Hypervel\Support\Str; - -$result = Str::of('LARAVEL')->lower(); - -// 'laravel' -``` - - -#### markdown - -The `markdown` method converts GitHub flavored Markdown into HTML: - -```php -use Hypervel\Support\Str; - -$html = Str::of('# Laravel')->markdown(); - -//
Laravel
- -$html = Str::of('# Taylor Otwell')->markdown([ - 'html_input' => 'strip', -]); - -//Taylor Otwell
-``` - -#### Markdown Security - -By default, Markdown supports raw HTML, which will expose Cross-Site Scripting (XSS) vulnerabilities when used with raw user input. As per the [CommonMark Security documentation](https://commonmark.thephpleague.com/security/), you may use the `html_input` option to either escape or strip raw HTML, and the `allow_unsafe_links` option to specify whether to allow unsafe links. If you need to allow some raw HTML, you should pass your compiled Markdown through an HTML Purifier: - -```php -use Hypervel\Support\Str; - -Str::of('Inject: ')->markdown([ - 'html_input' => 'strip', - 'allow_unsafe_links' => false, -]); - -//Inject: alert("Hello XSS!");
-``` - - -#### mask - -The `mask` method masks a portion of a string with a repeated character, and may be used to obfuscate segments of strings such as email addresses and phone numbers: - -```php -use Hypervel\Support\Str; - -$string = Str::of('taylor@example.com')->mask('*', 3); - -// tay*************** -``` - -If needed, you may provide negative numbers as the third or fourth argument to the `mask` method, which will instruct the method to begin masking at the given distance from the end of the string: - -```php -$string = Str::of('taylor@example.com')->mask('*', -15, 3); - -// tay***@example.com - -$string = Str::of('taylor@example.com')->mask('*', 4, -4); - -// tayl**********.com -``` - - -#### match - -The `match` method will return the portion of a string that matches a given regular expression pattern: - -```php -use Hypervel\Support\Str; - -$result = Str::of('foo bar')->match('/bar/'); - -// 'bar' - -$result = Str::of('foo bar')->match('/foo (.*)/'); - -// 'bar' -``` - - -#### matchAll - -The `matchAll` method will return a collection containing the portions of a string that match a given regular expression pattern: - -```php -use Hypervel\Support\Str; - -$result = Str::of('bar foo bar')->matchAll('/bar/'); - -// collect(['bar', 'bar']) -``` - -If you specify a matching group within the expression, Hypervel will return a collection of the first matching group's matches: - -```php -use Hypervel\Support\Str; - -$result = Str::of('bar fun bar fly')->matchAll('/f(\w*)/'); - -// collect(['un', 'ly']); -``` - -If no matches are found, an empty collection will be returned. - - -#### isMatch - -The `isMatch` method will return `true` if the string matches a given regular expression: - -```php -use Hypervel\Support\Str; - -$result = Str::of('foo bar')->isMatch('/foo (.*)/'); - -// true - -$result = Str::of('laravel')->isMatch('/foo (.*)/'); - -// false -``` - - -#### newLine - -The `newLine` method appends an "end of line" character to a string: - -```php -use Hypervel\Support\Str; - -$padded = Str::of('Laravel')->newLine()->append('Framework'); - -// 'Laravel -// Framework' -``` - - -#### padBoth - -The `padBoth` method wraps PHP's `str_pad` function, padding both sides of a string with another string until the final string reaches the desired length: - -```php -use Hypervel\Support\Str; - -$padded = Str::of('James')->padBoth(10, '_'); - -// '__James___' - -$padded = Str::of('James')->padBoth(10); - -// ' James ' -``` - - -#### padLeft - -The `padLeft` method wraps PHP's `str_pad` function, padding the left side of a string with another string until the final string reaches the desired length: - -```php -use Hypervel\Support\Str; - -$padded = Str::of('James')->padLeft(10, '-='); - -// '-=-=-James' - -$padded = Str::of('James')->padLeft(10); - -// ' James' -``` - - -#### padRight - -The `padRight` method wraps PHP's `str_pad` function, padding the right side of a string with another string until the final string reaches the desired length: - -```php -use Hypervel\Support\Str; - -$padded = Str::of('James')->padRight(10, '-'); - -// 'James-----' - -$padded = Str::of('James')->padRight(10); - -// 'James ' -``` - - -#### pipe - -The `pipe` method allows you to transform the string by passing its current value to the given callable: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$hash = Str::of('Laravel')->pipe('md5')->prepend('Checksum: '); - -// 'Checksum: a5c95b86291ea299fcbe64458ed12702' - -$closure = Str::of('foo')->pipe(function (Stringable $str) { - return 'bar'; -}); - -// 'bar' -``` - - -#### plural - -The `plural` method converts a singular word string to its plural form. This function supports [any of the languages support by Laravel's pluralizer](/docs/localization#pluralization-language): - -```php -use Hypervel\Support\Str; - -$plural = Str::of('car')->plural(); - -// cars - -$plural = Str::of('child')->plural(); - -// children -``` - -You may provide an integer as a second argument to the function to retrieve the singular or plural form of the string: - -```php -use Hypervel\Support\Str; - -$plural = Str::of('child')->plural(2); - -// children - -$plural = Str::of('child')->plural(1); - -// child -``` - - -#### position - -The `position` method returns the position of the first occurrence of a substring in a string. If the substring does not exist within the string, `false` is returned: - -```php -use Hypervel\Support\Str; - -$position = Str::of('Hello, World!')->position('Hello'); - -// 0 - -$position = Str::of('Hello, World!')->position('W'); - -// 7 -``` - - -#### prepend - -The `prepend` method prepends the given values onto the string: - -```php -use Hypervel\Support\Str; - -$string = Str::of('Framework')->prepend('Hypervel '); - -// Hypervel Framework -``` - - -#### remove - -The `remove` method removes the given value or array of values from the string: - -```php -use Hypervel\Support\Str; - -$string = Str::of('Arkansas is quite beautiful!')->remove('quite'); - -// Arkansas is beautiful! -``` - -You may also pass `false` as a second parameter to ignore case when removing strings. - - -#### repeat - -The `repeat` method repeats the given string: - -```php -use Hypervel\Support\Str; - -$repeated = Str::of('a')->repeat(5); - -// aaaaa -``` - - -#### replace - -The `replace` method replaces a given string within the string: - -```php -use Hypervel\Support\Str; - -$replaced = Str::of('Laravel 6.x')->replace('6.x', '7.x'); - -// Laravel 7.x -``` - -The `replace` method also accepts a `caseSensitive` argument. By default, the `replace` method is case sensitive: - -```php -$replaced = Str::of('macOS 13.x')->replace( - 'macOS', 'iOS', caseSensitive: false -); -``` - - -#### replaceArray - -The `replaceArray` method replaces a given value in the string sequentially using an array: - -```php -use Hypervel\Support\Str; - -$string = 'The event will take place between ? and ?'; - -$replaced = Str::of($string)->replaceArray('?', ['8:30', '9:00']); - -// The event will take place between 8:30 and 9:00 -``` - - -#### replaceFirst - -The `replaceFirst` method replaces the first occurrence of a given value in a string: - -```php -use Hypervel\Support\Str; - -$replaced = Str::of('the quick brown fox jumps over the lazy dog')->replaceFirst('the', 'a'); - -// a quick brown fox jumps over the lazy dog -``` - - -#### replaceLast - -The `replaceLast` method replaces the last occurrence of a given value in a string: - -```php -use Hypervel\Support\Str; - -$replaced = Str::of('the quick brown fox jumps over the lazy dog')->replaceLast('the', 'a'); - -// the quick brown fox jumps over a lazy dog -``` - - -#### replaceMatches - -The `replaceMatches` method replaces all portions of a string matching a pattern with the given replacement string: - -```php -use Hypervel\Support\Str; - -$replaced = Str::of('(+1) 501-555-1000')->replaceMatches('/[^A-Za-z0-9]++/', '') - -// '15015551000' -``` - -The `replaceMatches` method also accepts a closure that will be invoked with each portion of the string matching the given pattern, allowing you to perform the replacement logic within the closure and return the replaced value: - -```php -use Hypervel\Support\Str; - -$replaced = Str::of('123')->replaceMatches('/\d/', function (array $matches) { - return '['.$matches[0].']'; -}); - -// '[1][2][3]' -``` - - -#### replaceStart - -The `replaceStart` method replaces the first occurrence of the given value only if the value appears at the start of the string: - -```php -use Hypervel\Support\Str; - -$replaced = Str::of('Hello World')->replaceStart('Hello', 'Laravel'); - -// Laravel World - -$replaced = Str::of('Hello World')->replaceStart('World', 'Laravel'); - -// Hello World -``` - - -#### replaceEnd - -The `replaceEnd` method replaces the last occurrence of the given value only if the value appears at the end of the string: - -```php -use Hypervel\Support\Str; - -$replaced = Str::of('Hello World')->replaceEnd('World', 'Laravel'); - -// Hello Laravel - -$replaced = Str::of('Hello World')->replaceEnd('Hello', 'Laravel'); - -// Hello World -``` - - -#### scan - -The `scan` method parses input from a string into a collection according to a format supported by the [`sscanf` PHP function](https://www.php.net/manual/en/function.sscanf.php): - -```php -use Hypervel\Support\Str; - -$collection = Str::of('filename.jpg')->scan('%[^.].%s'); - -// collect(['filename', 'jpg']) -``` - - -#### singular - -The `singular` method converts a string to its singular form. This function supports [any of the languages support by Laravel's pluralizer](/docs/localization#pluralization-language): - -```php -use Hypervel\Support\Str; - -$singular = Str::of('cars')->singular(); - -// car - -$singular = Str::of('children')->singular(); - -// child -``` - - -#### slug - -The `slug` method generates a URL friendly "slug" from the given string: - -```php -use Hypervel\Support\Str; - -$slug = Str::of('Hypervel Framework')->slug('-'); - -// hypervel-framework -``` - - -#### snake - -The `snake` method converts the given string to `snake_case`: - -```php -use Hypervel\Support\Str; - -$converted = Str::of('fooBar')->snake(); - -// foo_bar -``` - - -#### split - -The `split` method splits a string into a collection using a regular expression: - -```php -use Hypervel\Support\Str; - -$segments = Str::of('one, two, three')->split('/[\s,]+/'); - -// collect(["one", "two", "three"]) -``` - - -#### squish - -The `squish` method removes all extraneous white space from a string, including extraneous white space between words: - -```php -use Hypervel\Support\Str; - -$string = Str::of(' Hypervel framework ')->squish(); - -// Hypervel framework -``` - - -#### start - -The `start` method adds a single instance of the given value to a string if it does not already start with that value: - -```php -use Hypervel\Support\Str; - -$adjusted = Str::of('this/string')->start('/'); - -// /this/string - -$adjusted = Str::of('/this/string')->start('/'); - -// /this/string -``` - - -#### startsWith - -The `startsWith` method determines if the given string begins with the given value: - -```php -use Hypervel\Support\Str; - -$result = Str::of('This is my name')->startsWith('This'); - -// true -``` - - -#### stripTags - -The `stripTags` method removes all HTML and PHP tags from a string: - -```php -use Hypervel\Support\Str; - -$result = Str::of('Taylor Otwell')->stripTags(); - -// Taylor Otwell - -$result = Str::of('Taylor Otwell')->stripTags(''); - -// Taylor Otwell -``` - - -#### studly - -The `studly` method converts the given string to `StudlyCase`: - -```php -use Hypervel\Support\Str; - -$converted = Str::of('foo_bar')->studly(); - -// FooBar -``` - - -#### substr - -The `substr` method returns the portion of the string specified by the given start and length parameters: - -```php -use Hypervel\Support\Str; - -$string = Str::of('Laravel Framework')->substr(8); - -// Framework - -$string = Str::of('Laravel Framework')->substr(8, 5); - -// Frame -``` - - -#### substrReplace - -The `substrReplace` method replaces text within a portion of a string, starting at the position specified by the second argument and replacing the number of characters specified by the third argument. Passing `0` to the method's third argument will insert the string at the specified position without replacing any of the existing characters in the string: - -```php -use Hypervel\Support\Str; - -$string = Str::of('1300')->substrReplace(':', 2); - -// 13: - -$string = Str::of('The Framework')->substrReplace(' Laravel', 3, 0); - -// The Laravel Framework -``` - - -#### swap - -The `swap` method replaces multiple values in the string using PHP's `strtr` function: - -```php -use Hypervel\Support\Str; - -$string = Str::of('Tacos are great!') - ->swap([ - 'Tacos' => 'Burritos', - 'great' => 'fantastic', - ]); - -// Burritos are fantastic! -``` - - -#### take - -The `take` method returns a specified number of characters from the beginning of the string: - -```php -use Hypervel\Support\Str; - -$taken = Str::of('Build something amazing!')->take(5); - -// Build -``` - - -#### tap - -The `tap` method passes the string to the given closure, allowing you to examine and interact with the string while not affecting the string itself. The original string is returned by the `tap` method regardless of what is returned by the closure: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('Laravel') - ->append(' Framework') - ->tap(function (Stringable $string) { - dump('String after append: '.$string); - }) - ->upper(); - -// LARAVEL FRAMEWORK -``` - - -#### test - -The `test` method determines if a string matches the given regular expression pattern: - -```php -use Hypervel\Support\Str; - -$result = Str::of('Laravel Framework')->test('/Laravel/'); - -// true -``` - - -#### title - -The `title` method converts the given string to `Title Case`: - -```php -use Hypervel\Support\Str; - -$converted = Str::of('a nice title uses the correct case')->title(); - -// A Nice Title Uses The Correct Case -``` - - -#### toBase64 - -The `toBase64` method converts the given string to Base64: - -```php -use Hypervel\Support\Str; - -$base64 = Str::of('Laravel')->toBase64(); - -// TGFyYXZlbA== -``` - - -#### trim - -The `trim` method trims the given string. Unlike PHP's native `trim` function, Laravel's `trim` method also removes unicode whitespace characters: - -```php -use Hypervel\Support\Str; - -$string = Str::of(' Hypervel ')->trim(); - -// 'Hypervel' - -$string = Str::of('/Hypervel/')->trim('/'); - -// 'Hypervel' -``` - - -#### ltrim - -The `ltrim` method trims the left side of the string. Unlike PHP's native `ltrim` function, Laravel's `ltrim` method also removes unicode whitespace characters: - -```php -use Hypervel\Support\Str; - -$string = Str::of(' Hypervel ')->ltrim(); - -// 'Hypervel ' - -$string = Str::of('/Hypervel/')->ltrim('/'); - -// 'Hypervel/' -``` - - -#### rtrim - -The `rtrim` method trims the right side of the given string. Unlike PHP's native `rtrim` function, Laravel's `rtrim` method also removes unicode whitespace characters: - -```php -use Hypervel\Support\Str; - -$string = Str::of(' Hypervel ')->rtrim(); - -// ' Hypervel' - -$string = Str::of('/Hypervel/')->rtrim('/'); - -// '/Hypervel' -``` - - -#### ucfirst - -The `ucfirst` method returns the given string with the first character capitalized: - -```php -use Hypervel\Support\Str; - -$string = Str::of('foo bar')->ucfirst(); - -// Foo bar -``` - - -#### ucsplit - -The `ucsplit` method splits the given string into a collection by uppercase characters: - -```php -use Hypervel\Support\Str; - -$string = Str::of('Foo Bar')->ucsplit(); - -// collect(['Foo', 'Bar']) -``` - - -#### unwrap - -The `unwrap` method removes the specified strings from the beginning and end of a given string: - -```php -use Hypervel\Support\Str; - -Str::of('-Laravel-')->unwrap('-'); - -// Laravel - -Str::of('{framework: "Laravel"}')->unwrap('{', '}'); - -// framework: "Laravel" -``` - - -#### upper - -The `upper` method converts the given string to uppercase: - -```php -use Hypervel\Support\Str; - -$adjusted = Str::of('laravel')->upper(); - -// LARAVEL -``` - - -#### when - -The `when` method invokes the given closure if a given condition is `true`. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('Taylor') - ->when(true, function (Stringable $string) { - return $string->append(' Otwell'); - }); - -// 'Taylor Otwell' -``` - -If necessary, you may pass another closure as the third parameter to the `when` method. This closure will execute if the condition parameter evaluates to `false`. - - -#### whenContains - -The `whenContains` method invokes the given closure if the string contains the given value. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('tony stark') - ->whenContains('tony', function (Stringable $string) { - return $string->title(); - }); - -// 'Tony Stark' -``` - -If necessary, you may pass another closure as the third parameter to the `when` method. This closure will execute if the string does not contain the given value. - -You may also pass an array of values to determine if the given string contains any of the values in the array: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('tony stark') - ->whenContains(['tony', 'hulk'], function (Stringable $string) { - return $string->title(); - }); - -// Tony Stark -``` - - -#### whenContainsAll - -The `whenContainsAll` method invokes the given closure if the string contains all of the given sub-strings. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('tony stark') - ->whenContainsAll(['tony', 'stark'], function (Stringable $string) { - return $string->title(); - }); - -// 'Tony Stark' -``` - -If necessary, you may pass another closure as the third parameter to the `when` method. This closure will execute if the condition parameter evaluates to `false`. - - -#### whenEmpty - -The `whenEmpty` method invokes the given closure if the string is empty. If the closure returns a value, that value will also be returned by the `whenEmpty` method. If the closure does not return a value, the fluent string instance will be returned: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of(' ')->whenEmpty(function (Stringable $string) { - return $string->trim()->prepend('Laravel'); -}); - -// 'Laravel' -``` - - -#### whenNotEmpty - -The `whenNotEmpty` method invokes the given closure if the string is not empty. If the closure returns a value, that value will also be returned by the `whenNotEmpty` method. If the closure does not return a value, the fluent string instance will be returned: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('Framework')->whenNotEmpty(function (Stringable $string) { - return $string->prepend('Hypervel '); -}); - -// 'Hypervel Framework' -``` - - -#### whenStartsWith - -The `whenStartsWith` method invokes the given closure if the string starts with the given sub-string. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('disney world')->whenStartsWith('disney', function (Stringable $string) { - return $string->title(); -}); - -// 'Disney World' -``` - - -#### whenEndsWith - -The `whenEndsWith` method invokes the given closure if the string ends with the given sub-string. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('disney world')->whenEndsWith('world', function (Stringable $string) { - return $string->title(); -}); - -// 'Disney World' -``` - - -#### whenExactly - -The `whenExactly` method invokes the given closure if the string exactly matches the given string. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('laravel')->whenExactly('laravel', function (Stringable $string) { - return $string->title(); -}); - -// 'Laravel' -``` - - -#### whenNotExactly - -The `whenNotExactly` method invokes the given closure if the string does not exactly match the given string. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('framework')->whenNotExactly('laravel', function (Stringable $string) { - return $string->title(); -}); - -// 'Framework' -``` - - -#### whenIs - -The `whenIs` method invokes the given closure if the string matches a given pattern. Asterisks may be used as wildcard values. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('foo/bar')->whenIs('foo/*', function (Stringable $string) { - return $string->append('/baz'); -}); - -// 'foo/bar/baz' -``` - - -#### whenIsAscii - -The `whenIsAscii` method invokes the given closure if the string is 7 bit ASCII. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('laravel')->whenIsAscii(function (Stringable $string) { - return $string->title(); -}); - -// 'Laravel' -``` - - -#### whenIsUlid - -The `whenIsUlid` method invokes the given closure if the string is a valid ULID. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; - -$string = Str::of('01gd6r360bp37zj17nxb55yv40')->whenIsUlid(function (Stringable $string) { - return $string->substr(0, 8); -}); - -// '01gd6r36' -``` - - -#### whenIsUuid - -The `whenIsUuid` method invokes the given closure if the string is a valid UUID. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('a0a2a2d2-0b87-4a18-83f2-2529882be2de')->whenIsUuid(function (Stringable $string) { - return $string->substr(0, 8); -}); - -// 'a0a2a2d2' -``` - - -#### whenTest - -The `whenTest` method invokes the given closure if the string matches the given regular expression. The closure will receive the fluent string instance: - -```php -use Hypervel\Support\Str; -use Hypervel\Support\Stringable; - -$string = Str::of('laravel framework')->whenTest('/laravel/', function (Stringable $string) { - return $string->title(); -}); - -// 'Laravel Framework' -``` - - -#### wordCount - -The `wordCount` method returns the number of words that a string contains: - -```php -use Hypervel\Support\Str; - -Str::of('Hello, world!')->wordCount(); // 2 -``` - - -#### words - -The `words` method limits the number of words in a string. If necessary, you may specify an additional string that will be appended to the truncated string: - -```php -use Hypervel\Support\Str; - -$string = Str::of('Perfectly balanced, as all things should be.')->words(3, ' >>>'); - -// Perfectly balanced, as >>> -``` - - -#### wrap - -The `wrap` method wraps the given string with an additional string or pair of strings: - -```php -use Hypervel\Support\Str; - -Str::of('Laravel')->wrap('"'); - -// "Laravel" - -Str::is('is')->wrap(before: 'This ', after: ' Laravel!'); - -// This is Laravel! -``` \ No newline at end of file diff --git a/_archive/docs/0.3/docs/structure.md b/_archive/docs/0.3/docs/structure.md deleted file mode 100644 index 5f4612abca..0000000000 --- a/_archive/docs/0.3/docs/structure.md +++ /dev/null @@ -1,174 +0,0 @@ -# Directory Structure -[[toc]] - -## Introduction - -The default Hypervel application structure follows by Laravel. It can provide you a great starting point for both large and small applications. You're free to organize your application however you like. But some directories such as `bootstrap`, `config`, `database` and `runtime` should remain due to the core design in Hypervel. - -Here's how you directory structure looks like: - -```plaintext:no-line-numbers -├── app -│ ├── Console -│ │ └── Commands -│ ├── Events -│ ├── Exceptions -│ ├── Http -│ │ ├── Controllers -│ │ ├── Middleware -│ │ └── Requests -| |── Jobs -│ ├── Listeners -│ ├── Models -│ └── Providers -├── bootstrap -├── config -├── database -│ ├── factories -│ ├── migrations -│ └── seeders -├── lang -│ ├── en -│ ├── zh_CN -│ └── zh_TW -|── public -|── resources -├── routes -├── runtime -│ └── container -├── storage -│ ├── app -| ├── framework -│ └── logs -└── tests - ├── Feature - └── Unit -``` - -## The Root Directory - -### The App Directory - -The `app` directory contains the core code of your application. We'll explore this directory in more detail soon; however, almost all of the classes in your application will be in this directory. - -### The Bootstrap Directory - -The `bootstrap` directory contains the `app.php` file which bootstraps the framework. - -### The Runtime Directory - -This directory stores files generated by Hypervel during runtime. It houses a `container` directory which contains framework generated files for caching the scanning result. - -### The Config Directory - -The `config` directory, as the name implies, contains all of your application's configuration files. It's a great idea to read through all of these files and familiarize yourself with all of the options available to you. - -::: warning -There's additional `autoload` directory inside `config` in Hyperf. This folder is removed in Hypervel. All the config files are flattened as Laravel does. - -`hyperf.php` is preserved for the compatibility of root configs in Hyperf. All the configs here will not include any prefixes. And all the configs in `config/config.php` are moved to `config/app.php` in Hypervel. -::: - -### The Database Directory - -The `database` directory contains your database migrations, model factories, and seeds. If you wish, you may also use this directory to hold an SQLite database. - -### The Public Directory - -The public directory houses your static assets such as images, JavaScript, and CSS. - -### The Resources Directory - -The `resources` directory contains your [views](/docs/views) as well as your raw, un-compiled assets such as CSS or JavaScript. - -### The Lang Directory - -The `lang` directory contains the translation files. Within this directory, there may be subdirectories for each language supported by the application. This is the approach Hypervel uses to manage translation strings for built-in features such as validation error messages. - -### The Routes Directory - -The `routes` directory contains all of the route definitions for your application. By default, three route files are included with Hypervel: `web.php`, `api.php` and `console.php`. - -The `web.php` file contains routes that serves common requests such as views, files in Hypervel. - -The `api.php` file contains routes that are intended to be stateless, so requests entering the application through these routes are intended to be authenticated and will not have access to session state. - -::: info -Middleware groups are applied to `web.php` and `api.php`, but are kept in empty by default. You can configure them manually if in need. -::: - -The `console.php` file is where you may define all of your closure based console commands. Each closure is bound to a command instance allowing a simple approach to interacting with each command's IO methods. Even though this file does not define HTTP routes, it defines console based entry points (routes) into your application. You may also [schedule](/docs/scheduling) tasks in the `console.php` file. - -### The Storage Directory - -The `storage` directory contains your logs, compiled Blade templates, file caches, and other files generated by the framework. This directory is segregated into `app`, `framework`, and `logs` directories. The `app` directory may be used to store any files generated by your application. The `framework` directory is used to store caches (and framework generated files in the future). Finally, the `logs` directory contains your application's log files. - -The `storage/app/public` directory may be used to store user-generated files, such as profile avatars, that should be publicly accessible. You should create a symbolic link at `public/storage` which points to this directory. - -### The Tests Directory - -The `tests` directory contains your automated tests. Example [PHPUnit](https://phpunit.de/) unit tests and feature tests are provided out of the box. Each test class should be suffixed with the word `Test`. You may run your tests using the `/vendor/bin/phpunit` commands. - -::: note -Pest package is not supported yet. -::: - -## The App Directory - -The majority of your application is housed in the `app` directory. By default, this directory is namespaced under `App` and is autoloaded by Composer using the [PSR-4 autoloading standard](https://www.php-fig.org/psr/psr-4/). - -The `app` directory contains a variety of additional directories such as `Console`, `Http`, and `Providers`. Think of the `Console` and `Http` directories as providing an API into the core of your application. The HTTP protocol and CLI are both mechanisms to interact with your application, but do not actually contain application logic. In other words, they are two ways of issuing commands to your application. The `Console` directory contains all of your Artisan commands, while the `Http` directory contains your controllers, middleware, and requests. - -::: note -Many of the classes in the `app` directory can be generated by Hypervel via commands. To review the available commands, run the `php artisan list make` command in your terminal. -::: - -### The Console Directory - -The `Console` directory contains all of the custom Artisan commands for your application. These commands may be generated using the `make:command` command. This directory also houses your console kernel, which is where your custom Artisan commands are registered and your [scheduled tasks](/docs/scheduling) are defined. - -### The Events Directory - -The `Events` directory houses [event classes](/docs/events). Events may be used to alert other parts of your application that a given action has occurred, providing a great deal of flexibility and decoupling. - -### The Exceptions Directory - -The `Exceptions` directory contains your application's exception handler and is also a good place to place any exceptions thrown by your application. If you would like to customize how your exceptions are logged or rendered, you should modify the Handler class in this directory. - -### The Http Directory - -The `Http` directory contains your controllers, middleware, and form requests. Almost all of the logic to handle requests entering your application will be placed in this directory. - -### The Jobs Directory - -This directory does not exist by default, but will be created for you if you execute the `make:job` Artisan command. The `Jobs` directory houses the [queueable jobs](/docs/queues) for your application. Jobs may be queued by your application or run synchronously within the current request lifecycle. Jobs that run synchronously during the current request are sometimes referred to as "commands" since they are an implementation of the [command pattern](https://en.wikipedia.org/wiki/Command_pattern). - -### The Listeners Directory - -The `Listeners` directory contains the classes that handle your [events](/docs/events). Event listeners receive an event instance and perform logic in response to the event being fired. For example, a `UserRegistered` event might be handled by a `SendWelcomeEmail` listener. If you execute the `make:listener` command, listener classes will be placed in this directory. - -### The Mail Directory - -This directory does not exist by default, but will be created for you if you execute the `make:mail` Artisan command. The `Mail` directory contains all of your [classes that represent emails](/docs/mail) sent by your application. Mail objects allow you to encapsulate all of the logic of building an email in a single, simple class that may be sent using the `Mail::send` method. - -### The Models Directory - -The `Models` directory contains all of your [Eloquent model classes](/docs/eloquent). The Eloquent ORM included with Hypervel provides a beautiful, simple ActiveRecord implementation for working with your database. Each database table has a corresponding "Model" which is used to interact with that table. Models allow you to query for data in your tables, as well as insert new records into the table. - -### The Notifications Directory - -This directory does not exist by default, but will be created for you if you execute the `make:notification` Artisan command. The `Notifications` directory contains all of the "transactional" [notifications](/docs/notifications) that are sent by your application, such as simple notifications about events that happen within your application. Laravel's notification feature abstracts sending notifications over a variety of drivers such as email, Slack, SMS, or stored in a database. - -### The Policies Directory - -This directory does not exist by default, but will be created for you if you execute the `make:policy` Artisan command. The `Policies` directory contains the [authorization policy classes](/docs/authorization) for your application. Policies are used to determine if a user can perform a given action against a resource. - -### The Providers Directory - -The `Providers` directory contains all of the [service providers](/docs/providers) for your application. Service providers bootstrap your application by binding services in the service container, registering events, or performing any other tasks to prepare your application for incoming requests. - -In a fresh Hypervel application, this directory will already contain several providers. You are free to add your own providers to this directory as needed. - -### The Rules Directory - -This directory does not exist by default, but will be created for you if you execute the `make:rule` Artisan command. The `Rules` directory contains the custom validation rule objects for your application. Rules are used to encapsulate complicated validation logic in a simple object. For more information, check out the [validation documentation](/docs/validation). \ No newline at end of file diff --git a/_archive/docs/0.3/docs/telescope.md b/_archive/docs/0.3/docs/telescope.md deleted file mode 100644 index 211900caf2..0000000000 --- a/_archive/docs/0.3/docs/telescope.md +++ /dev/null @@ -1,404 +0,0 @@ -# Hypervel Telescope -[[toc]] - -## Introduction - -[Hypervel Telescope](https://github.com/hypervel/telescope) makes a wonderful companion to your local Hypervel development environment. Telescope provides insight into the requests coming into your application, exceptions, log entries, database queries, queued jobs, mail, notifications, cache operations, scheduled tasks, variable dumps, and more. - -
-
-## Installation
-
-You may use the Composer package manager to install Telescope into your Hypervel project:
-
-```shell
-composer require hypervel/telescope
-```
-
-After installing Telescope, publish its assets and migrations using the `vendor:publish` Artisan command. After installing Telescope, you should also run the `migrate` command in order to create the tables needed to store Telescope's data:
-
-```shell
-php artisan vendor:publish "Hypervel\Telescope\TelescopeServiceProvider"
-
-php artisan migrate
-```
-
-Finally, you may access the Telescope dashboard via the `/telescope` route.
-
-### Local Only Installation
-
-If you plan to only use Telescope to assist your local development, you may install Telescope using the `--dev` flag:
-
-```shell
-composer require hypervel/telescope --dev
-
-php artisan vendor:publish "Hypervel\Telescope\TelescopeServiceProvider"
-
-php artisan migrate
-```
-
-After running `vendor:publish`, you should remove the `TelescopeServiceProvider` service provider registration from your application's `bootstrap/providers.php` configuration file. Instead, manually register Telescope's service providers in the `register` method of your `App\Providers\AppServiceProvider` class. We will ensure the current environment is `local` before registering the providers:
-
-```php
-/**
- * Register any application services.
- */
-public function register(): void
-{
- if ($this->app->environment('local') && class_exists(\Hypervel\Telescope\TelescopeServiceProvider::class)) {
- $this->app->register(\Hypervel\Telescope\TelescopeServiceProvider::class);
- $this->app->register(TelescopeServiceProvider::class);
- }
-}
-```
-
-Finally, you should also prevent the Telescope package from being [auto-discovered](/docs/packages#package-discovery) by adding the following to your `composer.json` file:
-
-```json
-"extra": {
- "hypervel": {
- "dont-discover": [
- "hypervel/telescope"
- ]
- }
-},
-```
-
-### Configuration
-
-After publishing Telescope's assets, its primary configuration file will be located at `config/telescope.php`. This configuration file allows you to configure your [watcher options](#available-watchers). Each configuration option includes a description of its purpose, so be sure to thoroughly explore this file.
-
-If desired, you may disable Telescope's data collection entirely using the `enabled` configuration option:
-
-```php
-'enabled' => env('TELESCOPE_ENABLED', true),
-```
-
-### Data Pruning
-
-Without pruning, the `telescope_entries` table can accumulate records very quickly. To mitigate this, you should [schedule](/docs/scheduling) the `telescope:prune` Artisan command to run daily:
-
-```php
-use Hypervel\Support\Facades\Schedule;
-
-Schedule::command('telescope:prune')->daily();
-```
-
-By default, all entries older than 24 hours will be pruned. You may use the `hours` option when calling the command to determine how long to retain Telescope data. For example, the following command will delete all records created over 48 hours ago:
-
-```php
-use Hypervel\Support\Facades\Schedule;
-
-Schedule::command('telescope:prune --hours=48')->daily();
-```
-
-### Dashboard Authorization
-
-The Telescope dashboard may be accessed via the `/telescope` route. By default, you will only be able to access this dashboard in the `local` environment. Within your `app/Providers/TelescopeServiceProvider.php` file, there is an [authorization gate](/docs/authorization#gates) definition. This authorization gate controls access to Telescope in **non-local** environments. You are free to modify this gate as needed to restrict access to your Telescope installation:
-
-```php
-use App\Models\User;
-
-/**
- * Register the Telescope gate.
- *
- * This gate determines who can access Telescope in non-local environments.
- */
-protected function gate(): void
-{
- Gate::define('viewTelescope', function (User $user) {
- return in_array($user->email, [
- 'albert@hypervel.org',
- ]);
- });
-}
-```
-
-::: warning
-You should ensure you change your `APP_ENV` environment variable to `production` in your production environment. Otherwise, your Telescope installation will be publicly available.
-:::
-
-## Filtering
-
-### Entries
-
-You may filter the data that is recorded by Telescope via the `filter` closure that is defined in your `App\Providers\TelescopeServiceProvider` class. By default, this closure records all data in the `local` environment and exceptions, failed jobs, scheduled tasks, and data with monitored tags in all other environments:
-
-```php
-use Hypervel\Telescope\IncomingEntry;
-use Hypervel\Telescope\Telescope;
-
-/**
- * Register any application services.
- */
-public function register(): void
-{
- $this->hideSensitiveRequestDetails();
-
- Telescope::filter(function (IncomingEntry $entry) {
- if ($this->app->environment('local')) {
- return true;
- }
-
- return $entry->isReportableException() ||
- $entry->isFailedJob() ||
- $entry->isScheduledTask() ||
- $entry->isSlowQuery() ||
- $entry->hasMonitoredTag();
- });
-}
-```
-
-### Batches
-
-While the `filter` closure filters data for individual entries, you may use the `filterBatch` method to register a closure that filters all data for a given request or console command. If the closure returns `true`, all of the entries are recorded by Telescope:
-
-```php
-use Hypervel\Support\Collection;
-use Hypervel\Telescope\IncomingEntry;
-use Hypervel\Telescope\Telescope;
-
-/**
- * Register any application services.
- */
-public function register(): void
-{
- $this->hideSensitiveRequestDetails();
-
- Telescope::filterBatch(function (Collection $entries) {
- if ($this->app->environment('local')) {
- return true;
- }
-
- return $entries->contains(function (IncomingEntry $entry) {
- return $entry->isReportableException() ||
- $entry->isFailedJob() ||
- $entry->isScheduledTask() ||
- $entry->isSlowQuery() ||
- $entry->hasMonitoredTag();
- });
- });
-}
-```
-
-## Tagging
-
-Telescope allows you to search entries by "tag". Often, tags are Eloquent model class names or authenticated user IDs which Telescope automatically adds to entries. Occasionally, you may want to attach your own custom tags to entries. To accomplish this, you may use the `Telescope::tag` method. The `tag` method accepts a closure which should return an array of tags. The tags returned by the closure will be merged with any tags Telescope would automatically attach to the entry. Typically, you should call the `tag` method within the `register` method of your `App\Providers\TelescopeServiceProvider` class:
-
-```php
-use Hypervel\Telescope\IncomingEntry;
-use Hypervel\Telescope\Telescope;
-
-/**
- * Register any application services.
- */
-public function register(): void
-{
- $this->hideSensitiveRequestDetails();
-
- Telescope::tag(function (IncomingEntry $entry) {
- return $entry->type === 'request'
- ? ['status:'.$entry->content['response_status']]
- : [];
- });
-}
-```
-
-## Available Watchers
-
-Telescope "watchers" gather application data when a request or console command is executed. You may customize the list of watchers that you would like to enable within your `config/telescope.php` configuration file:
-
-```php
-'watchers' => [
- Watchers\CacheWatcher::class => true,
- Watchers\CommandWatcher::class => true,
- // ...
-],
-```
-
-Some watchers also allow you to provide additional customization options:
-
-```php
-'watchers' => [
- Watchers\QueryWatcher::class => [
- 'enabled' => env('TELESCOPE_QUERY_WATCHER', true),
- 'slow' => 100,
- ],
- // ...
-],
-```
-
-### Batch Watcher
-
-The batch watcher records information about queued [batches](/docs/queues#job-batching), including the job and connection information.
-
-### Cache Watcher
-
-The cache watcher records data when a cache key is hit, missed, updated and forgotten.
-
-### Client Request Watcher
-
-The client request watcher records all HTTP requests sent via Guzzle's HTTP client.
-
-### Command Watcher
-
-The command watcher records the arguments, options, exit code, and output whenever an Artisan command is executed. If you would like to exclude certain commands from being recorded by the watcher, you may specify the command in the `ignore` option within your `config/telescope.php` file:
-
-```php
-'watchers' => [
- Watchers\CommandWatcher::class => [
- 'enabled' => env('TELESCOPE_COMMAND_WATCHER', true),
- 'ignore' => ['key:generate'],
- ],
- // ...
-]
-```
-
-### Dump Watcher
-
-The dump watcher records and displays your variable dumps in Telescope. When using Hypervel, variables may be dumped using the global `dump` function. The dump watcher tab must be open in a browser for the dump to be recorded, otherwise, the dumps will be ignored by the watcher.
-
-### Event Watcher
-
-The event watcher records the payload, listeners, and broadcast data for any [events](/docs/events) dispatched by your application. The Hypervel framework's internal events are ignored by the Event watcher.
-
-### Exception Watcher
-
-The exception watcher records the data and stack trace for any reportable exceptions that are thrown by your application.
-
-### Gate Watcher
-
-The gate watcher records the data and result of [gate and policy](/docs/authorization) checks by your application. If you would like to exclude certain abilities from being recorded by the watcher, you may specify those in the `ignore_abilities` option in your `config/telescope.php` file:
-
-```php
-'watchers' => [
- Watchers\GateWatcher::class => [
- 'enabled' => env('TELESCOPE_GATE_WATCHER', true),
- 'ignore_abilities' => ['viewNova'],
- ],
- // ...
-],
-```
-
-### HTTP Client Watcher
-
-The HTTP client watcher records outgoing [HTTP client requests](/docs/http-client) made by your application.
-
-### Job Watcher
-
-The job watcher records the data and status of any [jobs](/docs/queues) dispatched by your application.
-
-### Log Watcher
-
-The log watcher records the [log data](/docs/logging) for any logs written by your application.
-
-By default, Telescope will only record logs at the `error` level and above. However, you can modify the `level` option in your application's `config/telescope.php` configuration file to modify this behavior:
-
-```php
-'watchers' => [
- Watchers\LogWatcher::class => [
- 'enabled' => env('TELESCOPE_LOG_WATCHER', true),
- 'level' => 'debug',
- ],
-
- // ...
-],
-```
-
-### Mail Watcher
-
-The mail watcher allows you to view an in-browser preview of [emails](/docs/mail) sent by your application along with their associated data. You may also download the email as an `.eml` file.
-
-### Model Watcher
-
-The model watcher records model changes whenever an Eloquent [model event](/docs/eloquent#events) is dispatched. You may specify which model events should be recorded via the watcher's `events` option:
-
-```php
-'watchers' => [
- Watchers\ModelWatcher::class => [
- 'enabled' => env('TELESCOPE_MODEL_WATCHER', true),
- 'events' => ['eloquent.created*', 'eloquent.updated*'],
- ],
- // ...
-],
-```
-
-If you would like to record the number of models hydrated during a given request, enable the `hydrations` option:
-
-```php
-'watchers' => [
- Watchers\ModelWatcher::class => [
- 'enabled' => env('TELESCOPE_MODEL_WATCHER', true),
- 'events' => ['eloquent.created*', 'eloquent.updated*'],
- 'hydrations' => true,
- ],
- // ...
-],
-```
-
-### Notification Watcher
-
-The notification watcher records all [notifications](/docs/notifications) sent by your application. If the notification triggers an email and you have the mail watcher enabled, the email will also be available for preview on the mail watcher screen.
-
-### Query Watcher
-
-The query watcher records the raw SQL, bindings, and execution time for all queries that are executed by your application. The watcher also tags any queries slower than 100 milliseconds as `slow`. You may customize the slow query threshold using the watcher's `slow` option:
-
-```php
-'watchers' => [
- Watchers\QueryWatcher::class => [
- 'enabled' => env('TELESCOPE_QUERY_WATCHER', true),
- 'slow' => 50,
- ],
- // ...
-],
-```
-
-### Redis Watcher
-
-The Redis watcher records all [Redis](/docs/redis) commands executed by your application. If you are using Redis for caching, cache commands will also be recorded by the Redis watcher.
-
-### Request Watcher
-
-The request watcher records the request, headers, session, and response data associated with any requests handled by the application. You may limit your recorded response data via the `size_limit` (in kilobytes) option:
-
-```php
-'watchers' => [
- Watchers\RequestWatcher::class => [
- 'enabled' => env('TELESCOPE_REQUEST_WATCHER', true),
- 'size_limit' => env('TELESCOPE_RESPONSE_SIZE_LIMIT', 64),
- ],
- // ...
-],
-```
-
-### Schedule Watcher
-
-The schedule watcher records the command and output of any [scheduled tasks](/docs/scheduling) run by your application.
-
-### View Watcher
-
-The view watcher records the [view](/docs/views) name, path, data, and "composers" used when rendering views.
-
-## Displaying User Avatars
-
-The Telescope dashboard displays the user avatar for the user that was authenticated when a given entry was saved. By default, Telescope will retrieve avatars using the Gravatar web service. However, you may customize the avatar URL by registering a callback in your `App\Providers\TelescopeServiceProvider` class. The callback will receive the user's ID and email address and should return the user's avatar image URL:
-
-```php
-use App\Models\User;
-use Hypervel\Telescope\Telescope;
-
-/**
- * Register any application services.
- */
-public function register(): void
-{
- // ...
-
- Telescope::avatar(function (?string $id, ?string $email) {
- return ! is_null($id)
- ? '/avatars/'.User::find($id)->avatar_path
- : '/generic-avatar.jpg';
- });
-}
-```
\ No newline at end of file
diff --git a/_archive/docs/0.3/docs/testbench.md b/_archive/docs/0.3/docs/testbench.md
deleted file mode 100644
index 46df99d72e..0000000000
--- a/_archive/docs/0.3/docs/testbench.md
+++ /dev/null
@@ -1,141 +0,0 @@
-# Packages Toolkit: Testbench
-[[toc]]
-
-## Introduction
-
-Packages Toolkit for Hypervel is a collection of packages that have been designed to write, test, and preview your Hypervel packages.
-
-Before going through the rest of this documentation, please take some time to read the [Package Development](/docs/packages) section of Hypervel's own documentation, if you haven't done so yet.
-
-## Installation
-
-To start using Packages Toolkit for Hypervel you can first install the components:
-
-```shell:no-line-numbers
-composer require --dev hypervel/testbench
-```
-
-## Configuration
-
-The Packages Toolkit for Hypervel uses `testbench.yaml` as a configuration file where you can define the following schemas to be used within Workbench environment:
-
- Name | Type | Description
-:----------------|:----------|:--------------------
- `hypervel` | `string` | Set the path to Hypervel skeleton.
- `providers` | `array` | List of Service Provider classes to be loaded.
- `dont-discover` | `array` | List of packages to be ignored.
- `env` | `array` | Set environment variables to be loaded.
- `purge` | `array` | Configurable `files` and `directories` to be pruned after executing test cases.
- `workbench` | Object | See [Workbench configuration](#workbench-discovery-configuration) for details.
-
-## Basic Usages
-
-For the `testbench` command to understand any required service providers, bootstrappers, environment variables or other options to be used when executing the "artisan" command you need to add the following `testbench.yaml` file on the project root directory.
-
-```yaml
-providers:
- - Hypervel\Package\PackageServiceProvider
-
-dont-discover:
- - hypervel/sanctum
-```
-
-### Hypervel Skeleton
-
-You can use `hypervel` configuration key to set a custom location instead of using the default `vendor/hypervel/testbench/workbench`:
-
-```yaml
-hypervel: ./workbench
-```
-
-To publish the skeleton folder, you can run the following command:
-
-```shell:no-line-numbers
-vendor/bin/testbench-sync workbench
-```
-
-### Service Providers
-
-You can use `providers` configuration key to set an array of service providers to be loaded additionally:
-
-```yaml
-providers:
- - Hypervel\Sanctum\SanctumServiceProvider
- - Workbench\App\Providers\WorkbenchServiceProvider
-```
-
-### Exclude Packages
-
-To exclude specific packages, you can also use `dont-discover` to exclude specific packages from being loaded:
-
-```yaml
-dont-discover:
- - hypervel/html
-```
-
-### Environment Variables
-
-You can use `env` configuration key to set an array of environment variables to be loaded:
-
-```yaml
-env:
- - SEND_QUERIES_TO_RAY=(false)
-```
-
-::: warning
-The `env` environment variables are only applied when using the CLI and will not be used when running tests.
-:::
-
-#### Workbench Discovery Configuration
-
-The `discovers` configuration allows Workbench to discover routes and commands.
-
- Name | Type | Description
-:----------------|:--------------|:--------------------
- `web` | `bool` | Enabling the options allows Workbench to register routes from `workbench/routes/web.php`
- `api` | `bool` | Enabling the options allows Workbench to register routes from `workbench/routes/api.php`
- `commands` | `bool` | Enabling the options allows Workbench to register console commands from `workbench/routes/console.php`
-
-#### Example
-
-```yaml
-workbench:
- discovers:
- web: true
- api: false
- commands: false
-```
-
-## Getting Started
-
-To use Testbench Component, all you need to do is extend `Hypervel\Testbench\TestCase` instead of `PHPUnit\Framework\TestCase`. The fixture app booted by `Hypervel\Testbench\TestCase` is predefined to follow the base application skeleton of Hypervel.
-
-```php
-class TestCase extends \Hypervel\Testbench\TestCase
-{
- //
-}
-```
-
-### PHPUnit Configuration
-
-You can separate your tests in your `phpunit.xml` file by providing different test suites, allowing you to run your Feature tests on demand.
-
-For example:
-
-```yaml
-Create Post
- -@if ($errors->any()) -
-
-@endif
-
-
-```
-
-#### Customizing the Error Messages
-
-Hypervel's built-in validation rules each have an error message that is located in your application's `lang/en/validation.php` file. If your application does not have a `lang` directory, you may instruct Hypervel to create it using the `lang:publish` Artisan command.
-
-Within the `lang/en/validation.php` file, you will find a translation entry for each validation rule. You are free to change or modify these messages based on the needs of your application.
-
-In addition, you may copy this file to another language directory to translate the messages for your application's language. To learn more about Hypervel localization, check out the complete [localization documentation](/docs/localization).
-
-#### XHR Requests and Validation
-
-In this example, we used a traditional form to send data to the application. However, many applications receive XHR requests from a JavaScript powered frontend. When using the `validate` method during an XHR request, Hypervel will not generate a redirect response. Instead, Hypervel generates a [JSON response containing all of the validation errors](#validation-error-response-format). This JSON response will be sent with a 422 HTTP status code.
-
-#### The `@error` Directive
-
-You may use the `@error` [Blade](/docs/blade) directive to quickly determine if validation error messages exist for a given attribute. Within an `@error` directive, you may echo the `$message` variable to display the error message:
-
-```blade
-
-
-
-
-
-
-@error('title')
- -
- @foreach ($errors->all() as $error)
-
{{ $message }}
-@enderror
-```
-
-If you are using [named error bags](#named-error-bags), you may pass the name of the error bag as the second argument to the `@error` directive:
-
-```blade
-
-```
-
-### A Note on Optional Fields
-
-By default, Hypervel includes the `TrimStrings` and `ConvertEmptyStringsToNull` middleware in your application's global middleware stack. Because of this, you will often need to mark your "optional" request fields as `nullable` if you do not want the validator to consider `null` values as invalid. For example:
-
-```php
-$request->validate([
- 'title' => 'required|unique:posts|max:255',
- 'body' => 'required',
- 'publish_at' => 'nullable|date',
-]);
-```
-
-In this example, we are specifying that the `publish_at` field may be either `null` or a valid date representation. If the `nullable` modifier is not added to the rule definition, the validator would consider `null` an invalid date.
-
-### Validation Error Response Format
-
-When your application throws a `Hypervel\Validation\ValidationException` exception and the incoming HTTP request is expecting a JSON response, Hypervel will automatically format the error messages for you and return a `422 Unprocessable Entity` HTTP response.
-
-Below, you can review an example of the JSON response format for validation errors. Note that nested error keys are flattened into "dot" notation format:
-
-```json
-{
- "message": "The team name must be a string. (and 4 more errors)",
- "errors": {
- "team_name": [
- "The team name must be a string.",
- "The team name must be at least 1 characters."
- ],
- "authorization.role": [
- "The selected authorization.role is invalid."
- ],
- "users.0.email": [
- "The users.0.email field is required."
- ],
- "users.2.email": [
- "The users.2.email must be a valid email address."
- ]
- }
-}
-```
-
-## Form Request Validation
-
-### Creating Form Requests
-
-For more complex validation scenarios, you may wish to create a "form request". Form requests are custom request classes that encapsulate their own validation and authorization logic. To create a form request class, you may use the `make:request` Artisan CLI command:
-
-```shell
-php artisan make:request StorePostRequest
-```
-
-The generated form request class will be placed in the `app/Http/Requests` directory. If this directory does not exist, it will be created when you run the `make:request` command. Each form request generated by Hypervel has two methods: `authorize` and `rules`.
-
-As you might have guessed, the `authorize` method is responsible for determining if the currently authenticated user can perform the action represented by the request, while the `rules` method returns the validation rules that should apply to the request's data:
-
-```php
-/**
- * Get the validation rules that apply to the request.
- *
- * @return array
-
-- `array` - Casts to PHP array
-- `bool` / `boolean` - Casts to boolean
-- `collection` - Casts to Hypervel Collection
-- `date` - Casts to Carbon date (time set to 00:00:00)
-- `datetime` - Casts to Carbon datetime
-- `decimal:digits` - Casts to string with specified decimal places
-- `double` / `float` / `real` - Casts to float
-- `int` / `integer` - Casts to integer
-- `json` - Decodes JSON string to array
-- `object` - Decodes JSON string to object
-- `string` - Casts to string
-- `timestamp` - Casts to Unix timestamp
-
-
-
-#### Retrieving Casted Data
-
-After defining your casts, you can retrieve the casted data using the `casted()` method:
-
-```php
-public function store(CreatePostRequest $request)
-{
- // Get all casted data
- $data = $request->casted();
-
- // $data['published_at'] is now a Carbon instance
- // $data['views'] is now an integer
- // $data['is_featured'] is now a boolean
- // $data['tags'] is now an array
-
- Post::create($data);
-}
-```
-
-You can also retrieve specific casted values:
-
-```php
-// Get a single casted value
-$publishedAt = $request->casted('published_at');
-
-// Get multiple casted values
-$data = $request->casted(['published_at', 'views', 'is_featured']);
-```
-
-#### Casting Validation vs Raw Input
-
-By default, the `casted()` method works with validated data. You can also cast raw input data by passing `false` as the second parameter:
-
-```php
-// Cast validated data (default)
-$validatedData = $request->casted();
-
-// Cast raw input data
-$rawData = $request->casted(null, false);
-```
-
-#### Enum Casting
-
-You can cast request input to PHP enums:
-
-```php
- App\Enums\PostStatus::class,
-];
-
-public function store(CreatePostRequest $request)
-{
- $data = $request->casted();
- // $data['status'] is now a PostStatus enum instance
-}
-```
-
-#### DataObject Casting
-
-You can cast arrays to custom DataObject classes:
-
-```php
- App\DataObjects\PostMetadata::class,
-];
-
-public function store(CreatePostRequest $request)
-{
- $data = $request->casted();
- // $data['metadata'] is now a PostMetadata instance
-}
-```
-
-#### Custom Cast Classes
-
-For more complex casting logic, you can create custom cast classes that implement the `CastInputs` interface:
-
-```php
- App\Casts\UppercaseCast::class,
-];
-```
-
-#### Castable Classes
-
-You can also create "castable" classes that define their own casting logic:
-
-```php
- App\DataObjects\Money::class,
-];
-```
-
-::: note
-Form request casting provides a clean way to ensure your request data is in the correct format before it reaches your application logic, reducing the need for manual type conversion throughout your codebase.
-:::
-
-## Manually Creating Validators
-
-If you do not want to use the `validate` method on the request, you may create a validator instance manually using the `Validator` [facade](/docs/facades). The `make` method on the facade generates a new validator instance:
-
-```php
-all(), [
- 'title' => 'required|unique:posts|max:255',
- 'body' => 'required',
- ]);
-
- if ($validator->fails()) {
- return redirect('post/create');
- }
-
- // Retrieve the validated input...
- $validated = $validator->validated();
-
- // Store the blog post...
-
- return redirect('/posts');
- }
-}
-```
-
-The first argument passed to the `make` method is the data under validation. The second argument is an array of the validation rules that should be applied to the data.
-
-#### Stopping on First Validation Failure
-
-The `stopOnFirstFailure` method will inform the validator that it should stop validating all attributes once a single validation failure has occurred:
-
-```php
-if ($validator->stopOnFirstFailure()->fails()) {
- // ...
-}
-```
-
-### Automatic Redirection
-
-If you would like to create a validator instance manually but still take advantage of the automatic redirection offered by the HTTP request's `validate` method, you may call the `validate` method on an existing validator instance. If validation fails, the user will automatically be redirected or, in the case of an XHR request, a [JSON response will be returned](#validation-error-response-format):
-
-```php
-Validator::make($request->all(), [
- 'title' => 'required|unique:posts|max:255',
- 'body' => 'required',
-])->validate();
-```
-
-You may use the `validateWithBag` method to store the error messages in a [named error bag](#named-error-bags) if validation fails:
-
-```php
-Validator::make($request->all(), [
- 'title' => 'required|unique:posts|max:255',
- 'body' => 'required',
-])->validateWithBag('post');
-```
-
-
-### Customizing the Error Messages
-
-If needed, you may provide custom error messages that a validator instance should use instead of the default error messages provided by Hypervel. There are several ways to specify custom messages. First, you may pass the custom messages as the third argument to the `Validator::make` method:
-
-```php
-$validator = Validator::make($input, $rules, $messages = [
- 'required' => 'The :attribute field is required.',
-]);
-```
-
-In this example, the `:attribute` placeholder will be replaced by the actual name of the field under validation. You may also utilize other placeholders in validation messages. For example:
-
-```php
-$messages = [
- 'same' => 'The :attribute and :other must match.',
- 'size' => 'The :attribute must be exactly :size.',
- 'between' => 'The :attribute value :input is not between :min - :max.',
- 'in' => 'The :attribute must be one of the following types: :values',
-];
-```
-
-#### Specifying a Custom Message for a Given Attribute
-
-Sometimes you may wish to specify a custom error message only for a specific attribute. You may do so using "dot" notation. Specify the attribute's name first, followed by the rule:
-
-```php
-$messages = [
- 'email.required' => 'We need to know your email address!',
-];
-```
-
-#### Specifying Custom Attribute Values
-
-Many of Hypervel's built-in error messages include an `:attribute` placeholder that is replaced with the name of the field or attribute under validation. To customize the values used to replace these placeholders for specific fields, you may pass an array of custom attributes as the fourth argument to the `Validator::make` method:
-
-```php
-$validator = Validator::make($input, $rules, $messages, [
- 'email' => 'email address',
-]);
-```
-
-### Performing Additional Validation
-
-Sometimes you need to perform additional validation after your initial validation is complete. You can accomplish this using the validator's `after` method. The `after` method accepts a closure or an array of callables which will be invoked after validation is complete. The given callables will receive an `Hypervel\Validation\Validator` instance, allowing you to raise additional error messages if necessary:
-
-```php
-use Hypervel\Support\Facades\Validator;
-
-$validator = Validator::make(/* ... */);
-
-$validator->after(function ($validator) {
- if ($this->somethingElseIsInvalid()) {
- $validator->errors()->add(
- 'field', 'Something is wrong with this field!'
- );
- }
-});
-
-if ($validator->fails()) {
- // ...
-}
-```
-
-As noted, the `after` method also accepts an array of callables, which is particularly convenient if your "after validation" logic is encapsulated in invokable classes, which will receive an `Hypervel\Validation\Validator` instance via their `__invoke` method:
-
-```php
-use App\Validation\ValidateShippingTime;
-use App\Validation\ValidateUserStatus;
-
-$validator->after([
- new ValidateUserStatus,
- new ValidateShippingTime,
- function ($validator) {
- // ...
- },
-]);
-```
-
-## Working With Validated Input
-
-After validating incoming request data using a form request or a manually created validator instance, you may wish to retrieve the incoming request data that actually underwent validation. This can be accomplished in several ways. First, you may call the `validated` method on a form request or validator instance. This method returns an array of the data that was validated:
-
-```php
-$validated = $request->validated();
-
-$validated = $validator->validated();
-```
-
-## Working With Error Messages
-
-After calling the `errors` method on a `Validator` instance, you will receive an `Hyperf\Support\MessageBag` instance, which has a variety of convenient methods for working with error messages. The `$errors` variable that is automatically made available to all views is also an instance of the `MessageBag` class.
-
-#### Retrieving the First Error Message for a Field
-
-To retrieve the first error message for a given field, use the `first` method:
-
-```php
-$errors = $validator->errors();
-
-echo $errors->first('email');
-```
-
-#### Retrieving All Error Messages for a Field
-
-If you need to retrieve an array of all the messages for a given field, use the `get` method:
-
-```php
-foreach ($errors->get('email') as $message) {
- // ...
-}
-```
-
-If you are validating an array form field, you may retrieve all of the messages for each of the array elements using the `*` character:
-
-```php
-foreach ($errors->get('attachments.*') as $message) {
- // ...
-}
-```
-
-#### Retrieving All Error Messages for All Fields
-
-To retrieve an array of all messages for all fields, use the `all` method:
-
-```php
-foreach ($errors->all() as $message) {
- // ...
-}
-```
-
-#### Determining if Messages Exist for a Field
-
-The `has` method may be used to determine if any error messages exist for a given field:
-
-```php
-if ($errors->has('email')) {
- // ...
-}
-```
-
-### Specifying Custom Messages in Language Files
-
-Hypervel's built-in validation rules each have an error message that is located in your application's `lang/en/validation.php` file.
-
-Within the `lang/en/validation.php` file, you will find a translation entry for each validation rule. You are free to change or modify these messages based on the needs of your application.
-
-In addition, you may copy this file to another language directory to translate the messages for your application's language. To learn more about Hypervel localization, check out the complete [localization documentation](/docs/localization).
-
-#### Custom Messages for Specific Attributes
-
-You may customize the error messages used for specified attribute and rule combinations within your application's validation language files. To do so, add your message customizations to the `custom` array of your application's `lang/xx/validation.php` language file:
-
-```php
-'custom' => [
- 'email' => [
- 'required' => 'We need to know your email address!',
- 'max' => 'Your email address is too long!'
- ],
-],
-```
-
-### Specifying Attributes in Language Files
-
-Many of Hypervel's built-in error messages include an `:attribute` placeholder that is replaced with the name of the field or attribute under validation. If you would like the `:attribute` portion of your validation message to be replaced with a custom value, you may specify the custom attribute name in the `attributes` array of your `lang/xx/validation.php` language file:
-
-```php
-'attributes' => [
- 'email' => 'email address',
-],
-```
-
-### Specifying Values in Language Files
-
-Some of Hypervel's built-in validation rule error messages contain a `:value` placeholder that is replaced with the current value of the request attribute. However, you may occasionally need the `:value` portion of your validation message to be replaced with a custom representation of the value. For example, consider the following rule that specifies that a credit card number is required if the `payment_type` has a value of `cc`:
-
-```php
-Validator::make($request->all(), [
- 'credit_card_number' => 'required_if:payment_type,cc'
-]);
-```
-
-If this validation rule fails, it will produce the following error message:
-
-```text
-The credit card number field is required when payment type is cc.
-```
-
-Instead of displaying `cc` as the payment type value, you may specify a more user-friendly value representation in your `lang/xx/validation.php` language file by defining a `values` array:
-
-```php
-'values' => [
- 'payment_type' => [
- 'cc' => 'credit card'
- ],
-],
-```
-
-After defining this value, the validation rule will produce the following error message:
-
-```text
-The credit card number field is required when payment type is credit card.
-```
-
-## Available Validation Rules
-
-Below is a list of all available validation rules and their function:
-
-
-
-#### Booleans
-
-
-
-[Accepted](#rule-accepted)
-[Accepted If](#rule-accepted-if)
-[Boolean](#rule-boolean)
-[Declined](#rule-declined)
-[Declined If](#rule-declined-if)
-
-
-
-#### Strings
-
-
-
-[Active URL](#rule-active-url)
-[Alpha](#rule-alpha)
-[Alpha Dash](#rule-alpha-dash)
-[Alpha Numeric](#rule-alpha-num)
-[Ascii](#rule-ascii)
-[Confirmed](#rule-confirmed)
-[Current Password](#rule-current-password)
-[Different](#rule-different)
-[Doesnt Start With](#rule-doesnt-start-with)
-[Doesnt End With](#rule-doesnt-end-with)
-[Email](#rule-email)
-[Ends With](#rule-ends-with)
-[Enum](#rule-enum)
-[Hex Color](#rule-hex-color)
-[In](#rule-in)
-[IP Address](#rule-ip)
-[JSON](#rule-json)
-[Lowercase](#rule-lowercase)
-[MAC Address](#rule-mac)
-[Max](#rule-max)
-[Min](#rule-min)
-[Not In](#rule-not-in)
-[Regular Expression](#rule-regex)
-[Not Regular Expression](#rule-not-regex)
-[Same](#rule-same)
-[Size](#rule-size)
-[Starts With](#rule-starts-with)
-[String](#rule-string)
-[Uppercase](#rule-uppercase)
-[URL](#rule-url)
-[ULID](#rule-ulid)
-[UUID](#rule-uuid)
-
-
-
-#### Numbers
-
-
-
-[Between](#rule-between)
-[Decimal](#rule-decimal)
-[Different](#rule-different)
-[Digits](#rule-digits)
-[Digits Between](#rule-digits-between)
-[Greater Than](#rule-gt)
-[Greater Than Or Equal](#rule-gte)
-[Integer](#rule-integer)
-[Less Than](#rule-lt)
-[Less Than Or Equal](#rule-lte)
-[Max](#rule-max)
-[Max Digits](#rule-max-digits)
-[Min](#rule-min)
-[Min Digits](#rule-min-digits)
-[Multiple Of](#rule-multiple-of)
-[Numeric](#rule-numeric)
-[Same](#rule-same)
-[Size](#rule-size)
-
-
-
-#### Arrays
-
-
-
-[Array](#rule-array)
-[Between](#rule-between)
-[Contains](#rule-contains)
-[Distinct](#rule-distinct)
-[In Array](#rule-in-array)
-[List](#rule-list)
-[Max](#rule-max)
-[Min](#rule-min)
-[Size](#rule-size)
-
-
-
-#### Dates
-
-
-
-[After](#rule-after)
-[After Or Equal](#rule-after-or-equal)
-[Before](#rule-before)
-[Before Or Equal](#rule-before-or-equal)
-[Date](#rule-date)
-[Date Equals](#rule-date-equals)
-[Date Format](#rule-date-format)
-[Different](#rule-different)
-[Timezone](#rule-timezone)
-
-
-
-#### Files
-
-
-
-[Between](#rule-between)
-[Dimensions](#rule-dimensions)
-[Extensions](#rule-extensions)
-[File](#rule-file)
-[Image](#rule-image)
-[Max](#rule-max)
-[MIME Types](#rule-mimetypes)
-[MIME Type By File Extension](#rule-mimes)
-[Size](#rule-size)
-
-
-
-#### Database
-
-
-
-[Exists](#rule-exists)
-[Unique](#rule-unique)
-
-
-
-#### Utilities
-
-
-
-[Any Of](#rule-anyof)
-[Bail](#rule-bail)
-[Exclude](#rule-exclude)
-[Exclude If](#rule-exclude-if)
-[Exclude Unless](#rule-exclude-unless)
-[Exclude With](#rule-exclude-with)
-[Exclude Without](#rule-exclude-without)
-[Filled](#rule-filled)
-[Missing](#rule-missing)
-[Missing If](#rule-missing-if)
-[Missing Unless](#rule-missing-unless)
-[Missing With](#rule-missing-with)
-[Missing With All](#rule-missing-with-all)
-[Nullable](#rule-nullable)
-[Present](#rule-present)
-[Present If](#rule-present-if)
-[Present Unless](#rule-present-unless)
-[Present With](#rule-present-with)
-[Present With All](#rule-present-with-all)
-[Prohibited](#rule-prohibited)
-[Prohibited If](#rule-prohibited-if)
-[Prohibited If Accepted](#rule-prohibited-if-accepted)
-[Prohibited If Declined](#rule-prohibited-if-declined)
-[Prohibited Unless](#rule-prohibited-unless)
-[Prohibits](#rule-prohibits)
-[Required](#rule-required)
-[Required If](#rule-required-if)
-[Required If Accepted](#rule-required-if-accepted)
-[Required If Declined](#rule-required-if-declined)
-[Required Unless](#rule-required-unless)
-[Required With](#rule-required-with)
-[Required With All](#rule-required-with-all)
-[Required Without](#rule-required-without)
-[Required Without All](#rule-required-without-all)
-[Required Array Keys](#rule-required-array-keys)
-[Sometimes](#validating-when-present)
-
-
-
-
-#### accepted
-
-The field under validation must be `"yes"`, `"on"`, `1`, `"1"`, `true`, or `"true"`. This is useful for validating "Terms of Service" acceptance or similar fields.
-
-
-#### accepted_if:anotherfield,value,...
-
-The field under validation must be `"yes"`, `"on"`, `1`, `"1"`, `true`, or `"true"` if another field under validation is equal to a specified value. This is useful for validating "Terms of Service" acceptance or similar fields.
-
-
-#### active_url
-
-The field under validation must have a valid A or AAAA record according to the `dns_get_record` PHP function. The hostname of the provided URL is extracted using the `parse_url` PHP function before being passed to `dns_get_record`.
-
-
-#### after:_date_
-
-The field under validation must be a value after a given date. The dates will be passed into the `strtotime` PHP function in order to be converted to a valid `DateTime` instance:
-
-```php
-'start_date' => 'required|date|after:tomorrow'
-```
-
-Instead of passing a date string to be evaluated by `strtotime`, you may specify another field to compare against the date:
-
-```php
-'finish_date' => 'required|date|after:start_date'
-```
-
-For convenience, date based rules may be constructed using the fluent `date` rule builder:
-
-```php
-use Hypervel\Validation\Rule;
-
-'start_date' => [
- 'required',
- Rule::date()->after(today()->addDays(7)),
-],
-```
-
-The `afterToday` and `todayOrAfter` methods may be used to fluently express the date must be after today or or today or after, respectively:
-
-```php
-'start_date' => [
- 'required',
- Rule::date()->afterToday(),
-],
-```
-
-
-#### after\_or\_equal:_date_
-
-The field under validation must be a value after or equal to the given date. For more information, see the [after](#rule-after) rule.
-
-For convenience, date based rules may be constructed using the fluent `date` rule builder:
-
-```php
-use Hypervel\Validation\Rule;
-
-'start_date' => [
- 'required',
- Rule::date()->afterOrEqual(today()->addDays(7)),
-],
-```
-
-
-#### anyOf
-
-The `Rule::anyOf` validation rule allows you to specify that the field under validation must satisfy any of the given validation rulesets. For example, the following rule will validate that the `username` field is either an email address or an alpha-numeric string (including dashes) that is at least 6 characters long:
-
-```php
-use Hypervel\Validation\Rule;
-
-'username' => [
- 'required',
- Rule::anyOf([
- ['string', 'email'],
- ['string', 'alpha_dash', 'min:6'],
- ]),
-],
-```
-
-
-#### alpha
-
-The field under validation must be entirely Unicode alphabetic characters contained in [\p{L}](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AL%3A%5D&g=&i=) and [\p{M}](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AM%3A%5D&g=&i=).
-
-To restrict this validation rule to characters in the ASCII range (`a-z` and `A-Z`), you may provide the `ascii` option to the validation rule:
-
-```php
-'username' => 'alpha:ascii',
-```
-
-
-#### alpha_dash
-
-The field under validation must be entirely Unicode alpha-numeric characters contained in [\p{L}](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AL%3A%5D&g=&i=), [\p{M}](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AM%3A%5D&g=&i=), [\p{N}](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AN%3A%5D&g=&i=), as well as ASCII dashes (`-`) and ASCII underscores (`_`).
-
-To restrict this validation rule to characters in the ASCII range (`a-z`, `A-Z`, and `0-9`), you may provide the `ascii` option to the validation rule:
-
-```php
-'username' => 'alpha_dash:ascii',
-```
-
-
-#### alpha_num
-
-The field under validation must be entirely Unicode alpha-numeric characters contained in [\p{L}](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AL%3A%5D&g=&i=), [\p{M}](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AM%3A%5D&g=&i=), and [\p{N}](https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B%3AN%3A%5D&g=&i=).
-
-To restrict this validation rule to characters in the ASCII range (`a-z`, `A-Z`, and `0-9`), you may provide the `ascii` option to the validation rule:
-
-```php
-'username' => 'alpha_num:ascii',
-```
-
-
-#### array
-
-The field under validation must be a PHP `array`.
-
-When additional values are provided to the `array` rule, each key in the input array must be present within the list of values provided to the rule. In the following example, the `admin` key in the input array is invalid since it is not contained in the list of values provided to the `array` rule:
-
-```php
-use Hypervel\Support\Facades\Validator;
-
-$input = [
- 'user' => [
- 'name' => 'Taylor Otwell',
- 'username' => 'taylorotwell',
- 'admin' => true,
- ],
-];
-
-Validator::make($input, [
- 'user' => 'array:name,username',
-]);
-```
-
-In general, you should always specify the array keys that are allowed to be present within your array.
-
-
-#### ascii
-
-The field under validation must be entirely 7-bit ASCII characters.
-
-
-#### bail
-
-Stop running validation rules for the field after the first validation failure.
-
-While the `bail` rule will only stop validating a specific field when it encounters a validation failure, the `stopOnFirstFailure` method will inform the validator that it should stop validating all attributes once a single validation failure has occurred:
-
-```php
-if ($validator->stopOnFirstFailure()->fails()) {
- // ...
-}
-```
-
-
-#### before:_date_
-
-The field under validation must be a value preceding the given date. The dates will be passed into the PHP `strtotime` function in order to be converted into a valid `DateTime` instance. In addition, like the [after](#rule-after) rule, the name of another field under validation may be supplied as the value of `date`.
-
-For convenience, date based rules may also be constructed using the fluent `date` rule builder:
-
-```php
-use Hypervel\Validation\Rule;
-
-'start_date' => [
- 'required',
- Rule::date()->before(today()->subDays(7)),
-],
-```
-
-The `beforeToday` and `todayOrBefore` methods may be used to fluently express the date must be before today or or today or before, respectively:
-
-```php
-'start_date' => [
- 'required',
- Rule::date()->beforeToday(),
-],
-```
-
-
-#### before\_or\_equal:_date_
-
-The field under validation must be a value preceding or equal to the given date. The dates will be passed into the PHP `strtotime` function in order to be converted into a valid `DateTime` instance. In addition, like the [after](#rule-after) rule, the name of another field under validation may be supplied as the value of `date`.
-
-For convenience, date based rules may also be constructed using the fluent `date` rule builder:
-
-```php
-use Hypervel\Validation\Rule;
-
-'start_date' => [
- 'required',
- Rule::date()->beforeOrEqual(today()->subDays(7)),
-],
-```
-
-
-#### between:_min_,_max_
-
-The field under validation must have a size between the given _min_ and _max_ (inclusive). Strings, numerics, arrays, and files are evaluated in the same fashion as the [size](#rule-size) rule.
-
-
-#### boolean
-
-The field under validation must be able to be cast as a boolean. Accepted input are `true`, `false`, `1`, `0`, `"1"`, and `"0"`.
-
-
-#### confirmed
-
-The field under validation must have a matching field of `{field}_confirmation`. For example, if the field under validation is `password`, a matching `password_confirmation` field must be present in the input.
-
-You may also pass a custom confirmation field name. For example, `confirmed:repeat_username` will expect the field `repeat_username` to match the field under validation.
-
-
-#### contains:_foo_,_bar_,...
-
-The field under validation must be an array that contains all of the given parameter values.
-
-
-#### current_password
-
-The field under validation must match the authenticated user's password. You may specify an [authentication guard](/docs/authentication) using the rule's first parameter:
-
-```php
-'password' => 'current_password:api'
-```
-
-
-#### date
-
-The field under validation must be a valid, non-relative date according to the `strtotime` PHP function.
-
-
-#### date_equals:_date_
-
-The field under validation must be equal to the given date. The dates will be passed into the PHP `strtotime` function in order to be converted into a valid `DateTime` instance.
-
-
-#### date_format:_format_,...
-
-The field under validation must match one of the given _formats_. You should use **either** `date` or `date_format` when validating a field, not both. This validation rule supports all formats supported by PHP's [DateTime](https://www.php.net/manual/en/class.datetime.php) class.
-
-For convenience, date based rules may be constructed using the fluent `date` rule builder:
-
-```php
-use Hypervel\Validation\Rule;
-
-'start_date' => [
- 'required',
- Rule::date()->format('Y-m-d'),
-],
-```
-
-
-#### decimal:_min_,_max_
-
-The field under validation must be numeric and must contain the specified number of decimal places:
-
-```php
-// Must have exactly two decimal places (9.99)...
-'price' => 'decimal:2'
-
-// Must have between 2 and 4 decimal places...
-'price' => 'decimal:2,4'
-```
-
-
-#### declined
-
-The field under validation must be `"no"`, `"off"`, `0`, `"0"`, `false`, or `"false"`.
-
-
-#### declined_if:anotherfield,value,...
-
-The field under validation must be `"no"`, `"off"`, `0`, `"0"`, `false`, or `"false"` if another field under validation is equal to a specified value.
-
-
-#### different:_field_
-
-The field under validation must have a different value than _field_.
-
-
-#### digits:_value_
-
-The integer under validation must have an exact length of _value_.
-
-
-#### digits_between:_min_,_max_
-
-The integer validation must have a length between the given _min_ and _max_.
-
-
-#### dimensions
-
-The file under validation must be an image meeting the dimension constraints as specified by the rule's parameters:
-
-```php
-'avatar' => 'dimensions:min_width=100,min_height=200'
-```
-
-Available constraints are: _min\_width_, _max\_width_, _min\_height_, _max\_height_, _width_, _height_, _ratio_.
-
-A _ratio_ constraint should be represented as width divided by height. This can be specified either by a fraction like `3/2` or a float like `1.5`:
-
-```php
-'avatar' => 'dimensions:ratio=3/2'
-```
-
-Since this rule requires several arguments, it is often more convenient to use the `Rule::dimensions` method to fluently construct the rule:
-
-```php
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rule;
-
-Validator::make($data, [
- 'avatar' => [
- 'required',
- Rule::dimensions()
- ->maxWidth(1000)
- ->maxHeight(500)
- ->ratio(3 / 2),
- ],
-]);
-```
-
-
-#### distinct
-
-When validating arrays, the field under validation must not have any duplicate values:
-
-```php
-'foo.*.id' => 'distinct'
-```
-
-Distinct uses loose variable comparisons by default. To use strict comparisons, you may add the `strict` parameter to your validation rule definition:
-
-```php
-'foo.*.id' => 'distinct:strict'
-```
-
-You may add `ignore_case` to the validation rule's arguments to make the rule ignore capitalization differences:
-
-```php
-'foo.*.id' => 'distinct:ignore_case'
-```
-
-
-#### doesnt_start_with:_foo_,_bar_,...
-
-The field under validation must not start with one of the given values.
-
-
-#### doesnt_end_with:_foo_,_bar_,...
-
-The field under validation must not end with one of the given values.
-
-
-#### email
-
-The field under validation must be formatted as an email address. This validation rule utilizes the [egulias/email-validator](https://github.com/egulias/EmailValidator) package for validating the email address. By default, the `RFCValidation` validator is applied, but you can apply other validation styles as well:
-
-```php
-'email' => 'email:rfc,dns'
-```
-
-The example above will apply the `RFCValidation` and `DNSCheckValidation` validations. Here's a full list of validation styles you can apply:
-
-
-
-- `rfc`: `RFCValidation` - Validate the email address according to [supported RFCs](https://github.com/egulias/EmailValidator?tab=readme-ov-file#supported-rfcs).
-- `strict`: `NoRFCWarningsValidation` - Validate the email according to [supported RFCs](https://github.com/egulias/EmailValidator?tab=readme-ov-file#supported-rfcs), failing when warnings are found (e.g. trailing periods and multiple consecutive periods).
-- `dns`: `DNSCheckValidation` - Ensure the email address's domain has a valid MX record.
-- `spoof`: `SpoofCheckValidation` - Ensure the email address does not contain homograph or deceptive Unicode characters.
-- `filter`: `FilterEmailValidation` - Ensure the email address is valid according to PHP's `filter_var` function.
-- `filter_unicode`: `FilterEmailValidation::unicode()` - Ensure the email address is valid according to PHP's `filter_var` function, allowing some Unicode characters.
-
-
-
-For convenience, email validation rules may be built using the fluent rule builder:
-
-```php
-use Hypervel\Validation\Rule;
-
-$request->validate([
- 'email' => [
- 'required',
- Rule::email()
- ->rfcCompliant(strict: false)
- ->validateMxRecord()
- ->preventSpoofing()
- ],
-]);
-```
-
-::: warning
-The `dns` and `spoof` validators require the PHP `intl` extension.
-:::
-
-
-#### ends_with:_foo_,_bar_,...
-
-The field under validation must end with one of the given values.
-
-
-#### enum
-
-The `Enum` rule is a class based rule that validates whether the field under validation contains a valid enum value. The `Enum` rule accepts the name of the enum as its only constructor argument. When validating primitive values, a backed Enum should be provided to the `Enum` rule:
-
-```php
-use App\Enums\ServerStatus;
-use Hypervel\Validation\Rule;
-
-$request->validate([
- 'status' => [Rule::enum(ServerStatus::class)],
-]);
-```
-
-The `Enum` rule's `only` and `except` methods may be used to limit which enum cases should be considered valid:
-
-```php
-Rule::enum(ServerStatus::class)
- ->only([ServerStatus::Pending, ServerStatus::Active]);
-
-Rule::enum(ServerStatus::class)
- ->except([ServerStatus::Pending, ServerStatus::Active]);
-```
-
-The `when` method may be used to conditionally modify the `Enum` rule:
-
-```php
-use Hypervel\Support\Facades\Auth;
-use Hypervel\Validation\Rule;
-
-Rule::enum(ServerStatus::class)
- ->when(
- Auth::user()->isAdmin(),
- fn ($rule) => $rule->only(...),
- fn ($rule) => $rule->only(...),
- );
-```
-
-
-#### exclude
-
-The field under validation will be excluded from the request data returned by the `validate` and `validated` methods.
-
-
-#### exclude_if:_anotherfield_,_value_
-
-The field under validation will be excluded from the request data returned by the `validate` and `validated` methods if the _anotherfield_ field is equal to _value_.
-
-If complex conditional exclusion logic is required, you may utilize the `Rule::excludeIf` method. This method accepts a boolean or a closure. When given a closure, the closure should return `true` or `false` to indicate if the field under validation should be excluded:
-
-```php
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rule;
-
-Validator::make($request->all(), [
- 'role_id' => Rule::excludeIf($request->user()->is_admin),
-]);
-
-Validator::make($request->all(), [
- 'role_id' => Rule::excludeIf(fn () => $request->user()->is_admin),
-]);
-```
-
-
-#### exclude_unless:_anotherfield_,_value_
-
-The field under validation will be excluded from the request data returned by the `validate` and `validated` methods unless _anotherfield_'s field is equal to _value_. If _value_ is `null` (`exclude_unless:name,null`), the field under validation will be excluded unless the comparison field is `null` or the comparison field is missing from the request data.
-
-
-#### exclude_with:_anotherfield_
-
-The field under validation will be excluded from the request data returned by the `validate` and `validated` methods if the _anotherfield_ field is present.
-
-
-#### exclude_without:_anotherfield_
-
-The field under validation will be excluded from the request data returned by the `validate` and `validated` methods if the _anotherfield_ field is not present.
-
-
-#### exists:_table_,_column_
-
-The field under validation must exist in a given database table.
-
-
-#### Basic Usage of Exists Rule
-
-```php
-'state' => 'exists:states'
-```
-
-If the `column` option is not specified, the field name will be used. So, in this case, the rule will validate that the `states` database table contains a record with a `state` column value matching the request's `state` attribute value.
-
-
-#### Specifying a Custom Column Name
-
-You may explicitly specify the database column name that should be used by the validation rule by placing it after the database table name:
-
-```php
-'state' => 'exists:states,abbreviation'
-```
-
-Occasionally, you may need to specify a specific database connection to be used for the `exists` query. You can accomplish this by prepending the connection name to the table name:
-
-```php
-'email' => 'exists:connection.staff,email'
-```
-
-Instead of specifying the table name directly, you may specify the Eloquent model which should be used to determine the table name:
-
-```php
-'user_id' => 'exists:App\Models\User,id'
-```
-
-If you would like to customize the query executed by the validation rule, you may use the `Rule` class to fluently define the rule. In this example, we'll also specify the validation rules as an array instead of using the `|` character to delimit them:
-
-```php
-use Hyperf\Database\Query\Builder;
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rule;
-
-Validator::make($data, [
- 'email' => [
- 'required',
- Rule::exists('staff')->where(function (Builder $query) {
- $query->where('account_id', 1);
- }),
- ],
-]);
-```
-
-You may explicitly specify the database column name that should be used by the `exists` rule generated by the `Rule::exists` method by providing the column name as the second argument to the `exists` method:
-
-```php
-'state' => Rule::exists('states', 'abbreviation'),
-```
-
-Sometimes, you may wish to validate whether an array of values exists in the database. You can do so by adding both the `exists` and [array](#rule-array) rules to the field being validated:
-
-```php
-'states' => ['array', Rule::exists('states', 'abbreviation')],
-```
-
-When both of these rules are assigned to a field, Hypervel will automatically build a single query to determine if all of the given values exist in the specified table.
-
-
-#### extensions:_foo_,_bar_,...
-
-The file under validation must have a user-assigned extension corresponding to one of the listed extensions:
-
-```php
-'photo' => ['required', 'extensions:jpg,png'],
-```
-
-::: warning
-You should never rely on validating a file by its user-assigned extension alone. This rule should typically always be used in combination with the [mimes](#rule-mimes) or [mimetypes](#rule-mimetypes) rules.
-:::
-
-
-#### file
-
-The field under validation must be a successfully uploaded file.
-
-
-#### filled
-
-The field under validation must not be empty when it is present.
-
-
-#### gt:_field_
-
-The field under validation must be greater than the given _field_ or _value_. The two fields must be of the same type. Strings, numerics, arrays, and files are evaluated using the same conventions as the [size](#rule-size) rule.
-
-
-#### gte:_field_
-
-The field under validation must be greater than or equal to the given _field_ or _value_. The two fields must be of the same type. Strings, numerics, arrays, and files are evaluated using the same conventions as the [size](#rule-size) rule.
-
-
-#### hex_color
-
-The field under validation must contain a valid color value in [hexadecimal](https://developer.mozilla.org/en-US/docs/Web/CSS/hex-color) format.
-
-
-#### image
-
-The file under validation must be an image (jpg, jpeg, png, bmp, gif, or webp).
-
-::: warning
-By default, the image rule does not allow SVG files due to the possibility of XSS vulnerabilities. If you need to allow SVG files, you may provide the `allow_svg` directive to the `image` rule (`image:allow_svg`).
-:::
-
-
-#### in:_foo_,_bar_,...
-
-The field under validation must be included in the given list of values. Since this rule often requires you to `implode` an array, the `Rule::in` method may be used to fluently construct the rule:
-
-```php
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rule;
-
-Validator::make($data, [
- 'zones' => [
- 'required',
- Rule::in(['first-zone', 'second-zone']),
- ],
-]);
-```
-
-When the `in` rule is combined with the `array` rule, each value in the input array must be present within the list of values provided to the `in` rule. In the following example, the `LAS` airport code in the input array is invalid since it is not contained in the list of airports provided to the `in` rule:
-
-```php
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rule;
-
-$input = [
- 'airports' => ['NYC', 'LAS'],
-];
-
-Validator::make($input, [
- 'airports' => [
- 'required',
- 'array',
- ],
- 'airports.*' => Rule::in(['NYC', 'LIT']),
-]);
-```
-
-
-#### in_array:_anotherfield_.*
-
-The field under validation must exist in _anotherfield_'s values.
-
-
-#### integer
-
-The field under validation must be an integer.
-
-::: warning
-This validation rule does not verify that the input is of the "integer" variable type, only that the input is of a type accepted by PHP's `FILTER_VALIDATE_INT` rule. If you need to validate the input as being a number please use this rule in combination with [the `numeric` validation rule](#rule-numeric).
-:::
-
-
-#### ip
-
-The field under validation must be an IP address.
-
-
-#### ipv4
-
-The field under validation must be an IPv4 address.
-
-
-#### ipv6
-
-The field under validation must be an IPv6 address.
-
-
-#### json
-
-The field under validation must be a valid JSON string.
-
-
-#### lt:_field_
-
-The field under validation must be less than the given _field_. The two fields must be of the same type. Strings, numerics, arrays, and files are evaluated using the same conventions as the [size](#rule-size) rule.
-
-
-#### lte:_field_
-
-The field under validation must be less than or equal to the given _field_. The two fields must be of the same type. Strings, numerics, arrays, and files are evaluated using the same conventions as the [size](#rule-size) rule.
-
-
-#### lowercase
-
-The field under validation must be lowercase.
-
-
-#### list
-
-The field under validation must be an array that is a list. An array is considered a list if its keys consist of consecutive numbers from 0 to `count($array) - 1`.
-
-
-#### mac_address
-
-The field under validation must be a MAC address.
-
-
-#### max:_value_
-
-The field under validation must be less than or equal to a maximum _value_. Strings, numerics, arrays, and files are evaluated in the same fashion as the [size](#rule-size) rule.
-
-
-#### max_digits:_value_
-
-The integer under validation must have a maximum length of _value_.
-
-
-#### mimetypes:_text/plain_,...
-
-The file under validation must match one of the given MIME types:
-
-```php
-'video' => 'mimetypes:video/avi,video/mpeg,video/quicktime'
-```
-
-To determine the MIME type of the uploaded file, the file's contents will be read and the framework will attempt to guess the MIME type, which may be different from the client's provided MIME type.
-
-
-#### mimes:_foo_,_bar_,...
-
-The file under validation must have a MIME type corresponding to one of the listed extensions:
-
-```php
-'photo' => 'mimes:jpg,bmp,png'
-```
-
-Even though you only need to specify the extensions, this rule actually validates the MIME type of the file by reading the file's contents and guessing its MIME type. A full listing of MIME types and their corresponding extensions may be found at the following location:
-
-[https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types](https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types)
-
-#### MIME Types and Extensions
-
-This validation rule does not verify agreement between the MIME type and the extension the user assigned to the file. For example, the `mimes:png` validation rule would consider a file containing valid PNG content to be a valid PNG image, even if the file is named `photo.txt`. If you would like to validate the user-assigned extension of the file, you may use the [extensions](#rule-extensions) rule.
-
-
-#### min:_value_
-
-The field under validation must have a minimum _value_. Strings, numerics, arrays, and files are evaluated in the same fashion as the [size](#rule-size) rule.
-
-
-#### min_digits:_value_
-
-The integer under validation must have a minimum length of _value_.
-
-
-#### multiple_of:_value_
-
-The field under validation must be a multiple of _value_.
-
-
-#### missing
-
-The field under validation must not be present in the input data.
-
-
-#### missing_if:_anotherfield_,_value_,...
-
-The field under validation must not be present if the _anotherfield_ field is equal to any _value_.
-
-
-#### missing_unless:_anotherfield_,_value_
-
-The field under validation must not be present unless the _anotherfield_ field is equal to any _value_.
-
-
-#### missing_with:_foo_,_bar_,...
-
-The field under validation must not be present _only if_ any of the other specified fields are present.
-
-
-#### missing_with_all:_foo_,_bar_,...
-
-The field under validation must not be present _only if_ all of the other specified fields are present.
-
-
-#### not_in:_foo_,_bar_,...
-
-The field under validation must not be included in the given list of values. The `Rule::notIn` method may be used to fluently construct the rule:
-
-```php
-use Hypervel\Validation\Rule;
-
-Validator::make($data, [
- 'toppings' => [
- 'required',
- Rule::notIn(['sprinkles', 'cherries']),
- ],
-]);
-```
-
-
-#### not_regex:_pattern_
-
-The field under validation must not match the given regular expression.
-
-Internally, this rule uses the PHP `preg_match` function. The pattern specified should obey the same formatting required by `preg_match` and thus also include valid delimiters. For example: `'email' => 'not_regex:/^.+$/i'`.
-
-::: warning
-When using the `regex` / `not_regex` patterns, it may be necessary to specify your validation rules using an array instead of using `|` delimiters, especially if the regular expression contains a `|` character.
-:::
-
-
-#### nullable
-
-The field under validation may be `null`.
-
-
-#### numeric
-
-The field under validation must be [numeric](https://www.php.net/manual/en/function.is-numeric.php).
-
-
-#### present
-
-The field under validation must exist in the input data.
-
-
-#### present_if:_anotherfield_,_value_,...
-
-The field under validation must be present if the _anotherfield_ field is equal to any _value_.
-
-
-#### present_unless:_anotherfield_,_value_
-
-The field under validation must be present unless the _anotherfield_ field is equal to any _value_.
-
-
-#### present_with:_foo_,_bar_,...
-
-The field under validation must be present _only if_ any of the other specified fields are present.
-
-
-#### present_with_all:_foo_,_bar_,...
-
-The field under validation must be present _only if_ all of the other specified fields are present.
-
-
-#### prohibited
-
-The field under validation must be missing or empty. A field is "empty" if it meets one of the following criteria:
-
-
-
-- The value is `null`.
-- The value is an empty string.
-- The value is an empty array or empty `Countable` object.
-- The value is an uploaded file with an empty path.
-
-
-
-
-#### prohibited_if:_anotherfield_,_value_,...
-
-The field under validation must be missing or empty if the _anotherfield_ field is equal to any _value_. A field is "empty" if it meets one of the following criteria:
-
-
-
-- The value is `null`.
-- The value is an empty string.
-- The value is an empty array or empty `Countable` object.
-- The value is an uploaded file with an empty path.
-
-
-
-If complex conditional prohibition logic is required, you may utilize the `Rule::prohibitedIf` method. This method accepts a boolean or a closure. When given a closure, the closure should return `true` or `false` to indicate if the field under validation should be prohibited:
-
-```php
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rule;
-
-Validator::make($request->all(), [
- 'role_id' => Rule::prohibitedIf($request->user()->is_admin),
-]);
-
-Validator::make($request->all(), [
- 'role_id' => Rule::prohibitedIf(fn () => $request->user()->is_admin),
-]);
-```
-
-#### prohibited_if_accepted:_anotherfield_,...
-
-The field under validation must be missing or empty if the _anotherfield_ field is equal to `"yes"`, `"on"`, `1`, `"1"`, `true`, or `"true"`.
-
-
-#### prohibited_if_declined:_anotherfield_,...
-
-The field under validation must be missing or empty if the _anotherfield_ field is equal to `"no"`, `"off"`, `0`, `"0"`, `false`, or `"false"`.
-
-
-#### prohibited_unless:_anotherfield_,_value_,...
-
-The field under validation must be missing or empty unless the _anotherfield_ field is equal to any _value_. A field is "empty" if it meets one of the following criteria:
-
-
-
-- The value is `null`.
-- The value is an empty string.
-- The value is an empty array or empty `Countable` object.
-- The value is an uploaded file with an empty path.
-
-
-
-
-#### prohibits:_anotherfield_,...
-
-If the field under validation is not missing or empty, all fields in _anotherfield_ must be missing or empty. A field is "empty" if it meets one of the following criteria:
-
-
-
-- The value is `null`.
-- The value is an empty string.
-- The value is an empty array or empty `Countable` object.
-- The value is an uploaded file with an empty path.
-
-
-
-
-#### regex:_pattern_
-
-The field under validation must match the given regular expression.
-
-Internally, this rule uses the PHP `preg_match` function. The pattern specified should obey the same formatting required by `preg_match` and thus also include valid delimiters. For example: `'email' => 'regex:/^.+@.+$/i'`.
-
-::: warning
-When using the `regex` / `not_regex` patterns, it may be necessary to specify rules in an array instead of using `|` delimiters, especially if the regular expression contains a `|` character.
-:::
-
-
-#### required
-
-The field under validation must be present in the input data and not empty. A field is "empty" if it meets one of the following criteria:
-
-
-
-- The value is `null`.
-- The value is an empty string.
-- The value is an empty array or empty `Countable` object.
-- The value is an uploaded file with no path.
-
-
-
-
-#### required_if:_anotherfield_,_value_,...
-
-The field under validation must be present and not empty if the _anotherfield_ field is equal to any _value_.
-
-If you would like to construct a more complex condition for the `required_if` rule, you may use the `Rule::requiredIf` method. This method accepts a boolean or a closure. When passed a closure, the closure should return `true` or `false` to indicate if the field under validation is required:
-
-```php
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rule;
-
-Validator::make($request->all(), [
- 'role_id' => Rule::requiredIf($request->user()->is_admin),
-]);
-
-Validator::make($request->all(), [
- 'role_id' => Rule::requiredIf(fn () => $request->user()->is_admin),
-]);
-```
-
-
-#### required_if_accepted:_anotherfield_,...
-
-The field under validation must be present and not empty if the _anotherfield_ field is equal to `"yes"`, `"on"`, `1`, `"1"`, `true`, or `"true"`.
-
-
-#### required_if_declined:_anotherfield_,...
-
-The field under validation must be present and not empty if the _anotherfield_ field is equal to `"no"`, `"off"`, `0`, `"0"`, `false`, or `"false"`.
-
-
-#### required_unless:_anotherfield_,_value_,...
-
-The field under validation must be present and not empty unless the _anotherfield_ field is equal to any _value_. This also means _anotherfield_ must be present in the request data unless _value_ is `null`. If _value_ is `null` (`required_unless:name,null`), the field under validation will be required unless the comparison field is `null` or the comparison field is missing from the request data.
-
-
-#### required_with:_foo_,_bar_,...
-
-The field under validation must be present and not empty _only if_ any of the other specified fields are present and not empty.
-
-
-#### required_with_all:_foo_,_bar_,...
-
-The field under validation must be present and not empty _only if_ all of the other specified fields are present and not empty.
-
-
-#### required_without:_foo_,_bar_,...
-
-The field under validation must be present and not empty _only when_ any of the other specified fields are empty or not present.
-
-
-#### required_without_all:_foo_,_bar_,...
-
-The field under validation must be present and not empty _only when_ all of the other specified fields are empty or not present.
-
-
-#### required_array_keys:_foo_,_bar_,...
-
-The field under validation must be an array and must contain at least the specified keys.
-
-
-#### same:_field_
-
-The given _field_ must match the field under validation.
-
-
-#### size:_value_
-
-The field under validation must have a size matching the given _value_. For string data, _value_ corresponds to the number of characters. For numeric data, _value_ corresponds to a given integer value (the attribute must also have the `numeric` or `integer` rule). For an array, _size_ corresponds to the `count` of the array. For files, _size_ corresponds to the file size in kilobytes. Let's look at some examples:
-
-```php
-// Validate that a string is exactly 12 characters long...
-'title' => 'size:12';
-
-// Validate that a provided integer equals 10...
-'seats' => 'integer|size:10';
-
-// Validate that an array has exactly 5 elements...
-'tags' => 'array|size:5';
-
-// Validate that an uploaded file is exactly 512 kilobytes...
-'image' => 'file|size:512';
-```
-
-
-#### starts_with:_foo_,_bar_,...
-
-The field under validation must start with one of the given values.
-
-
-#### string
-
-The field under validation must be a string. If you would like to allow the field to also be `null`, you should assign the `nullable` rule to the field.
-
-
-#### timezone
-
-The field under validation must be a valid timezone identifier according to the `DateTimeZone::listIdentifiers` method.
-
-The arguments [accepted by the `DateTimeZone::listIdentifiers` method](https://www.php.net/manual/en/datetimezone.listidentifiers.php) may also be provided to this validation rule:
-
-```php
-'timezone' => 'required|timezone:all';
-
-'timezone' => 'required|timezone:Africa';
-
-'timezone' => 'required|timezone:per_country,US';
-```
-
-
-#### unique:_table_,_column_
-
-The field under validation must not exist within the given database table.
-
-**Specifying a Custom Table / Column Name:**
-
-Instead of specifying the table name directly, you may specify the Eloquent model which should be used to determine the table name:
-
-```php
-'email' => 'unique:App\Models\User,email_address'
-```
-
-The `column` option may be used to specify the field's corresponding database column. If the `column` option is not specified, the name of the field under validation will be used.
-
-```php
-'email' => 'unique:users,email_address'
-```
-
-**Specifying a Custom Database Connection**
-
-Occasionally, you may need to set a custom connection for database queries made by the Validator. To accomplish this, you may prepend the connection name to the table name:
-
-```php
-'email' => 'unique:connection.users,email_address'
-```
-
-**Forcing a Unique Rule to Ignore a Given ID:**
-
-Sometimes, you may wish to ignore a given ID during unique validation. For example, consider an "update profile" screen that includes the user's name, email address, and location. You will probably want to verify that the email address is unique. However, if the user only changes the name field and not the email field, you do not want a validation error to be thrown because the user is already the owner of the email address in question.
-
-To instruct the validator to ignore the user's ID, we'll use the `Rule` class to fluently define the rule. In this example, we'll also specify the validation rules as an array instead of using the `|` character to delimit the rules:
-
-```php
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rule;
-
-Validator::make($data, [
- 'email' => [
- 'required',
- Rule::unique('users')->ignore($user->id),
- ],
-]);
-```
-
-::: warning
-> You should never pass any user controlled request input into the `ignore` method. Instead, you should only pass a system generated unique ID such as an auto-incrementing ID or UUID from an Eloquent model instance. Otherwise, your application will be vulnerable to an SQL injection attack.
-:::
-
-Instead of passing the model key's value to the `ignore` method, you may also pass the entire model instance. Hypervel will automatically extract the key from the model:
-
-```php
-Rule::unique('users')->ignore($user)
-```
-
-If your table uses a primary key column name other than `id`, you may specify the name of the column when calling the `ignore` method:
-
-```php
-Rule::unique('users')->ignore($user->id, 'user_id')
-```
-
-By default, the `unique` rule will check the uniqueness of the column matching the name of the attribute being validated. However, you may pass a different column name as the second argument to the `unique` method:
-
-```php
-Rule::unique('users', 'email_address')->ignore($user->id)
-```
-
-**Adding Additional Where Clauses:**
-
-You may specify additional query conditions by customizing the query using the `where` method. For example, let's add a query condition that scopes the query to only search records that have an `account_id` column value of `1`:
-
-```php
-'email' => Rule::unique('users')->where(fn (Builder $query) => $query->where('account_id', 1))
-```
-
-**Ignoring Soft Deleted Records in Unique Checks:**
-
-By default, the unique rule includes soft deleted records when determining uniqueness. To exclude soft deleted records from the uniqueness check, you may invoke the `withoutTrashed` method:
-
-```php
-Rule::unique('users')->withoutTrashed();
-```
-
-If your model uses a column name other than `deleted_at` for soft deleted records, you may provide the column name when invoking the `withoutTrashed` method:
-
-```php
-Rule::unique('users')->withoutTrashed('was_deleted_at');
-```
-
-
-#### uppercase
-
-The field under validation must be uppercase.
-
-
-#### url
-
-The field under validation must be a valid URL.
-
-If you would like to specify the URL protocols that should be considered valid, you may pass the protocols as validation rule parameters:
-
-```php
-'url' => 'url:http,https',
-
-'game' => 'url:minecraft,steam',
-```
-
-
-#### ulid
-
-The field under validation must be a valid [Universally Unique Lexicographically Sortable Identifier](https://github.com/ulid/spec) (ULID).
-
-
-#### uuid
-
-The field under validation must be a valid RFC 9562 (version 1, 3, 4, 5, 6, 7, or 8) universally unique identifier (UUID).
-
-You may also validate that the given UUID matches a UUID specification by version:
-
-```php
-'uuid' => 'uuid:4'
-```
-
-
-## Conditionally Adding Rules
-
-
-#### Skipping Validation When Fields Have Certain Values
-
-You may occasionally wish to not validate a given field if another field has a given value. You may accomplish this using the `exclude_if` validation rule. In this example, the `appointment_date` and `doctor_name` fields will not be validated if the `has_appointment` field has a value of `false`:
-
-```php
-use Hypervel\Support\Facades\Validator;
-
-$validator = Validator::make($data, [
- 'has_appointment' => 'required|boolean',
- 'appointment_date' => 'exclude_if:has_appointment,false|required|date',
- 'doctor_name' => 'exclude_if:has_appointment,false|required|string',
-]);
-```
-
-Alternatively, you may use the `exclude_unless` rule to not validate a given field unless another field has a given value:
-
-```php
-$validator = Validator::make($data, [
- 'has_appointment' => 'required|boolean',
- 'appointment_date' => 'exclude_unless:has_appointment,true|required|date',
- 'doctor_name' => 'exclude_unless:has_appointment,true|required|string',
-]);
-```
-
-#### Validating When Present
-
-In some situations, you may wish to run validation checks against a field **only** if that field is present in the data being validated. To quickly accomplish this, add the `sometimes` rule to your rule list:
-
-```php
-$validator = Validator::make($data, [
- 'email' => 'sometimes|required|email',
-]);
-```
-
-In the example above, the `email` field will only be validated if it is present in the `$data` array.
-
-::: note
-If you are attempting to validate a field that should always be present but may be empty, check out [this note on optional fields](#a-note-on-optional-fields).
-:::
-
-#### Complex Conditional Validation
-
-Sometimes you may wish to add validation rules based on more complex conditional logic. For example, you may wish to require a given field only if another field has a greater value than 100. Or, you may need two fields to have a given value only when another field is present. Adding these validation rules doesn't have to be a pain. First, create a `Validator` instance with your _static rules_ that never change:
-
-```php
-use Hypervel\Support\Facades\Validator;
-
-$validator = Validator::make($request->all(), [
- 'email' => 'required|email',
- 'games' => 'required|integer|min:0',
-]);
-```
-
-Let's assume our web application is for game collectors. If a game collector registers with our application and they own more than 100 games, we want them to explain why they own so many games. For example, perhaps they run a game resale shop, or maybe they just enjoy collecting games. To conditionally add this requirement, we can use the `sometimes` method on the `Validator` instance.
-
-```php
-use Hypervel\Support\Fluent;
-
-$validator->sometimes('reason', 'required|max:500', function (Fluent $input) {
- return $input->games >= 100;
-});
-```
-
-The first argument passed to the `sometimes` method is the name of the field we are conditionally validating. The second argument is a list of the rules we want to add. If the closure passed as the third argument returns `true`, the rules will be added. This method makes it a breeze to build complex conditional validations. You may even add conditional validations for several fields at once:
-
-```php
-$validator->sometimes(['reason', 'cost'], 'required', function (Fluent $input) {
- return $input->games >= 100;
-});
-```
-
-::: note
-The `$input` parameter passed to your closure will be an instance of `Hypervel\Support\Fluent` and may be used to access your input and files under validation.
-:::
-
-#### Complex Conditional Array Validation
-
-Sometimes you may want to validate a field based on another field in the same nested array whose index you do not know. In these situations, you may allow your closure to receive a second argument which will be the current individual item in the array being validated:
-
-```php
-$input = [
- 'channels' => [
- [
- 'type' => 'email',
- 'address' => 'abigail@example.com',
- ],
- [
- 'type' => 'url',
- 'address' => 'https://example.com',
- ],
- ],
-];
-
-$validator->sometimes('channels.*.address', 'email', function (Fluent $input, Fluent $item) {
- return $item->type === 'email';
-});
-
-$validator->sometimes('channels.*.address', 'url', function (Fluent $input, Fluent $item) {
- return $item->type !== 'email';
-});
-```
-
-Like the `$input` parameter passed to the closure, the `$item` parameter is an instance of `Hypervel\Support\Fluent` when the attribute data is an array; otherwise, it is a string.
-
-## Validating Arrays
-
-As discussed in the [array validation rule documentation](#rule-array), the `array` rule accepts a list of allowed array keys. If any additional keys are present within the array, validation will fail:
-
-```php
-use Hypervel\Support\Facades\Validator;
-
-$input = [
- 'user' => [
- 'name' => 'Taylor Otwell',
- 'username' => 'taylorotwell',
- 'admin' => true,
- ],
-];
-
-Validator::make($input, [
- 'user' => 'array:name,username',
-]);
-```
-
-In general, you should always specify the array keys that are allowed to be present within your array. Otherwise, the validator's `validate` and `validated` methods will return all of the validated data, including the array and all of its keys, even if those keys were not validated by other nested array validation rules.
-
-### Validating Nested Array Input
-
-Validating nested array based form input fields doesn't have to be a pain. You may use "dot notation" to validate attributes within an array. For example, if the incoming HTTP request contains a `photos[profile]` field, you may validate it like so:
-
-```php
-use Hypervel\Support\Facades\Validator;
-
-$validator = Validator::make($request->all(), [
- 'photos.profile' => 'required|image',
-]);
-```
-
-You may also validate each element of an array. For example, to validate that each email in a given array input field is unique, you may do the following:
-
-```php
-$validator = Validator::make($request->all(), [
- 'person.*.email' => 'email|unique:users',
- 'person.*.first_name' => 'required_with:person.*.last_name',
-]);
-```
-
-Likewise, you may use the `*` character when specifying [custom validation messages in your language files](#custom-messages-for-specific-attributes), making it a breeze to use a single validation message for array based fields:
-
-```php
-'custom' => [
- 'person.*.email' => [
- 'unique' => 'Each person must have a unique email address',
- ]
-],
-```
-
-#### Accessing Nested Array Data
-
-Sometimes you may need to access the value for a given nested array element when assigning validation rules to the attribute. You may accomplish this using the `Rule::forEach` method. The `forEach` method accepts a closure that will be invoked for each iteration of the array attribute under validation and will receive the attribute's value and explicit, fully-expanded attribute name. The closure should return an array of rules to assign to the array element:
-
-```php
-use App\Rules\HasPermission;
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rule;
-
-$validator = Validator::make($request->all(), [
- 'companies.*.id' => Rule::forEach(function (string|null $value, string $attribute) {
- return [
- Rule::exists(Company::class, 'id'),
- new HasPermission('manage-company', $value),
- ];
- }),
-]);
-```
-
-### Error Message Indexes and Positions
-
-When validating arrays, you may want to reference the index or position of a particular item that failed validation within the error message displayed by your application. To accomplish this, you may include the `:index` (starts from `0`) and `:position` (starts from `1`) placeholders within your [custom validation message](#manual-customizing-the-error-messages):
-
-```php
-use Hypervel\Support\Facades\Validator;
-
-$input = [
- 'photos' => [
- [
- 'name' => 'BeachVacation.jpg',
- 'description' => 'A photo of my beach vacation!',
- ],
- [
- 'name' => 'GrandCanyon.jpg',
- 'description' => '',
- ],
- ],
-];
-
-Validator::validate($input, [
- 'photos.*.description' => 'required',
-], [
- 'photos.*.description.required' => 'Please describe photo #:position.',
-]);
-```
-
-Given the example above, validation will fail and the user will be presented with the following error of _"Please describe photo #2."_
-
-If necessary, you may reference more deeply nested indexes and positions via `second-index`, `second-position`, `third-index`, `third-position`, etc.
-
-```php
-'photos.*.attributes.*.string' => 'Invalid attribute for photo #:second-position.',
-```
-
-## Validating Files
-
-Hypervel provides a variety of validation rules that may be used to validate uploaded files, such as `mimes`, `image`, `min`, and `max`. While you are free to specify these rules individually when validating files, Hypervel also offers a fluent file validation rule builder that you may find convenient:
-
-```php
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rules\File;
-
-Validator::validate($input, [
- 'attachment' => [
- 'required',
- File::types(['mp3', 'wav'])
- ->min(1024)
- ->max(12 * 1024),
- ],
-]);
-```
-
-#### Validating File Types
-
-Even though you only need to specify the extensions when invoking the `types` method, this method actually validates the MIME type of the file by reading the file's contents and guessing its MIME type. A full listing of MIME types and their corresponding extensions may be found at the following location:
-
-[https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types](https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types)
-
-
-#### Validating File Sizes
-
-For convenience, minimum and maximum file sizes may be specified as a string with a suffix indicating the file size units. The `kb`, `mb`, `gb`, and `tb` suffixes are supported:
-
-```php
-File::types(['mp3', 'wav'])
- ->min('1kb')
- ->max('10mb');
-```
-
-
-#### Validating Image Files
-
-If your application accepts images uploaded by your users, you may use the `File` rule's `image` constructor method to ensure that the file under validation is an image (jpg, jpeg, png, bmp, gif, or webp).
-
-In addition, the `dimensions` rule may be used to limit the dimensions of the image:
-
-```php
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rule;
-use Hypervel\Validation\Rules\File;
-
-Validator::validate($input, [
- 'photo' => [
- 'required',
- File::image()
- ->min(1024)
- ->max(12 * 1024)
- ->dimensions(Rule::dimensions()->maxWidth(1000)->maxHeight(500)),
- ],
-]);
-```
-
-::: note
-More information regarding validating image dimensions may be found in the [dimension rule documentation](#rule-dimensions).
-:::
-
-::: warning
-By default, the `image` rule does not allow SVG files due to the possibility of XSS vulnerabilities. If you need to allow SVG files, you may pass `allowSvg: true` to the `image` rule: `File::image(allowSvg: true)`.
-:::
-
-
-#### Validating Image Dimensions
-
-You may also validate the dimensions of an image. For example, to validate that an uploaded image is at least 1000 pixels wide and 500 pixels tall, you may use the `dimensions` rule:
-
-```php
-use Hypervel\Validation\Rule;
-use Hypervel\Validation\Rules\File;
-
-File::image()->dimensions(
- Rule::dimensions()
- ->maxWidth(1000)
- ->maxHeight(500)
-)
-```
-
-::: note
-More information regarding validating image dimensions may be found in the [dimension rule documentation](#rule-dimensions).
-:::
-
-## Validating Passwords
-
-To ensure that passwords have an adequate level of complexity, you may use Hypervel's `Password` rule object:
-
-```php
-use Hypervel\Support\Facades\Validator;
-use Hypervel\Validation\Rules\Password;
-
-$validator = Validator::make($request->all(), [
- 'password' => ['required', 'confirmed', Password::min(8)],
-]);
-```
-
-The `Password` rule object allows you to easily customize the password complexity requirements for your application, such as specifying that passwords require at least one letter, number, symbol, or characters with mixed casing:
-
-```php
-// Require at least 8 characters...
-Password::min(8)
-
-// Require at least one letter...
-Password::min(8)->letters()
-
-// Require at least one uppercase and one lowercase letter...
-Password::min(8)->mixedCase()
-
-// Require at least one number...
-Password::min(8)->numbers()
-
-// Require at least one symbol...
-Password::min(8)->symbols()
-```
-
-In addition, you may ensure that a password has not been compromised in a public password data breach leak using the `uncompromised` method:
-
-```php
-Password::min(8)->uncompromised()
-```
-
-Internally, the `Password` rule object uses the [k-Anonymity](https://en.wikipedia.org/wiki/K-anonymity) model to determine if a password has been leaked via the [haveibeenpwned.com](https://haveibeenpwned.com) service without sacrificing the user's privacy or security.
-
-By default, if a password appears at least once in a data leak, it will be considered compromised. You can customize this threshold using the first argument of the `uncompromised` method:
-
-```php
-// Ensure the password appears less than 3 times in the same data leak...
-Password::min(8)->uncompromised(3);
-```
-
-Of course, you may chain all the methods in the examples above:
-
-```php
-Password::min(8)
- ->letters()
- ->mixedCase()
- ->numbers()
- ->symbols()
- ->uncompromised()
-```
-
-#### Defining Default Password Rules
-
-You may find it convenient to specify the default validation rules for passwords in a single location of your application. You can easily accomplish this using the `Password::defaults` method, which accepts a closure. The closure given to the `defaults` method should return the default configuration of the Password rule. Typically, the `defaults` rule should be called within the `boot` method of one of your application's service providers:
-
-```php
-use Hypervel\Validation\Rules\Password;
-
-/**
- * Bootstrap any application services.
- */
-public function boot(): void
-{
- Password::defaults(function () {
- $rule = Password::min(8);
-
- return $this->app->isProduction()
- ? $rule->mixedCase()->uncompromised()
- : $rule;
- });
-}
-```
-
-Then, when you would like to apply the default rules to a particular password undergoing validation, you may invoke the `defaults` method with no arguments:
-
-```php
-'password' => ['required', Password::defaults()],
-```
-
-Occasionally, you may want to attach additional validation rules to your default password validation rules. You may use the `rules` method to accomplish this:
-
-```php
-use App\Rules\ZxcvbnRule;
-
-Password::defaults(function () {
- $rule = Password::min(8)->rules([new ZxcvbnRule]);
-
- // ...
-});
-```
-
-## Custom Validation Rules
-
-### Using Rule Objects
-
-Hypervel provides a variety of helpful validation rules; however, you may wish to specify some of your own. One method of registering custom validation rules is using rule objects. To generate a new rule object, you may use the `make:rule` Artisan command. Let's use this command to generate a rule that verifies a string is uppercase. Hypervel will place the new rule in the `app/Rules` directory. If this directory does not exist, Hypervel will create it when you execute the Artisan command to create your rule:
-
-```shell
-php artisan make:rule Uppercase
-```
-
-Once the rule has been created, we are ready to define its behavior. A rule object contains a single method: `validate`. This method receives the attribute name, its value, and a callback that should be invoked on failure with the validation error message:
-
-```php
-validate([
- 'name' => ['required', 'string', new Uppercase],
-]);
-```
-
-#### Translating Validation Messages
-
-Instead of providing a literal error message to the `$fail` closure, you may also provide a [translation string key](/docs/localization) and instruct Hypervel to translate the error message:
-
-```php
-if (strtoupper($value) !== $value) {
- $fail('validation.uppercase')->translate();
-}
-```
-
-If necessary, you may provide placeholder replacements and the preferred language as the first and second arguments to the `translate` method:
-
-```php
-$fail('validation.location')->translate([
- 'value' => $this->value,
-], 'fr');
-```
-
-#### Accessing Additional Data
-
-If your custom validation rule class needs to access all of the other data undergoing validation, your rule class may implement the `Hypervel\Validation\Contracts\DataAwareRule` interface. This interface requires your class to define a `setData` method. This method will automatically be invoked by Hypervel (before validation proceeds) with all of the data under validation:
-
-```php
-
- */
- protected array $data = [];
-
- // ...
-
- /**
- * Set the data under validation.
- *
- * @param array