### Default Configuration File Content Source: https://github.com/spatie/laravel-model-states/blob/main/docs/04-installation-setup.md The default content of the configuration file for spatie/laravel-model-states. It specifies the default transition class to be used. ```php return [ /* * The fully qualified class name of the default transition. */ 'default_transition' => Spatie\ModelStates\DefaultTransition::class, ]; ``` -------------------------------- ### Install spatie/laravel-model-states via Composer Source: https://github.com/spatie/laravel-model-states/blob/main/docs/04-installation-setup.md Installs the spatie/laravel-model-states package into your Laravel project using Composer. This is the primary method for adding the package to your dependencies. ```bash composer require spatie/laravel-model-states ``` -------------------------------- ### Publish Configuration File Source: https://github.com/spatie/laravel-model-states/blob/main/docs/04-installation-setup.md Publishes the package's configuration file to your Laravel project using the `artisan vendor:publish` command. This allows for customization of package settings. ```bash php artisan vendor:publish --provider="Spatie\ModelStates\ModelStatesServiceProvider" --tag="model-states-config" ``` -------------------------------- ### Install Package via Composer Source: https://github.com/spatie/laravel-model-states/blob/main/README.md Installs the spatie/laravel-model-states package using Composer. This is the primary method for adding the package to your Laravel project. ```bash composer require spatie/laravel-model-states ``` -------------------------------- ### Using Model States and Transitions (PHP) Source: https://github.com/spatie/laravel-model-states/blob/main/docs/01-introduction.md This example demonstrates how to interact with the stateful model. It shows retrieving a model, transitioning its state to 'Paid', and accessing state-specific behavior like the `color()` method. ```php $payment = Payment::find(1); $payment->state->transitionTo(Paid::class); echo $payment->state->color(); ``` -------------------------------- ### Define State Methods for UI/Logic Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/04-retrieving-transitionable-states.md Example of defining abstract methods in a base state class and implementing them in concrete states. These methods can be called directly on state instances, as shown in Blade examples. ```php abstract class PaymentState extends State { abstract public function color(): string; abstract public function label(): string; abstract public function icon(): string; // ...other state methods } class Paid extends PaymentState { public function color(): string { return '#4CAF50'; // green } public function label(): string { return 'Mark as Paid'; } public function icon(): string { return 'check-circle'; } } ``` -------------------------------- ### Transition State and Get State Property Source: https://github.com/spatie/laravel-model-states/blob/main/README.md Demonstrates how to interact with the state management. It shows finding a model, transitioning its state, and accessing a state-specific property. ```php $payment = Payment::find(1); $payment->state->transitionTo(Paid::class); echo $payment->state->color(); ``` -------------------------------- ### Register States from Directory Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/01-configuring-states.md Automates the discovery and registration of all state classes residing within specified directories. This simplifies setup when you have many state classes organized in folders. ```php use Spatie\ModelStates\State; use Spatie\ModelStates\StateConfig; abstract class PaymentState extends State { abstract public function color(): string; public static function config(): StateConfig { return parent::config() ->default(Pending::class) ->allowTransition(Pending::class, Paid::class) ->allowTransition(Pending::class, Failed::class) ->registerStatesFromDirectory(app_path('States/Payment')) ->registerStatesFromDirectory( __DIR__ . '/States', __DIR__ . '/MoreStates', // add as many directories as you need ); } } ``` -------------------------------- ### Abstract Payment State Class Configuration (PHP) Source: https://github.com/spatie/laravel-model-states/blob/main/docs/01-introduction.md This example illustrates the structure of an abstract state class for the model. It defines an abstract method for state-specific behavior and configures allowed transitions and the default state using `StateConfig`. ```php use Spatie\ModelStates\State; use Spatie\ModelStates\StateConfig; abstract class PaymentState extends State { abstract public function color(): string; public static function config(): StateConfig { return parent::config() ->default(Pending::class) ->allowTransition(Pending::class, Paid::class) ->allowTransition(Pending::class, Failed::class) ; } } ``` -------------------------------- ### Get All Default States Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/03-listing-states.md Retrieves all default state classes, keyed by the column they are associated with, using the `Invoice::getDefaultStates()` method. This shows the default state for each configured attribute. ```php Invoice::getDefaultStates() ``` ```json { "state": 'App\States\Invoice\Pending', "fulfillment": null, } ``` -------------------------------- ### Define Invoice Model with States Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/03-listing-states.md Sets up an Eloquent model `Invoice` using the `HasStates` trait and defines state casting for 'state' and 'fulfillment' attributes. This is a foundational setup for using model states. ```php namespace App; use App\States\Invoice\InvoiceState; use App\States\Invoice\Declined; use App\States\Invoice\Paid; use App\States\Invoice\Pending; use App\States\Fulfillment\FulfillmentState; use App\States\Fulfillment\Complete; use App\States\Fulfillment\Partial; use App\States\Fulfillment\Unfulfilled; use Illuminate\Database\Eloquent\Model; use Spatie\ModelStates\HasStates; class Invoice extends Model { use HasStates; protected $casts = [ 'state' => InvoiceState::class, 'fulfillment' => FulfillmentState::class, ]; } ``` -------------------------------- ### Retrieve Transitionable States Count Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/04-retrieving-transitionable-states.md Gets the total number of available transitions from the current state. This method provides a simple count of possible next states. ```php $stateCount = $payment->state->transitionableStatesCount(); // Example: 4 ``` -------------------------------- ### Get All Registered States Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/03-listing-states.md Retrieves all registered state morph names, grouped by the column they are associated with, using the `Invoice::getStates()` method. This provides an overview of all available states across different attributes. ```php Invoice::getStates() ``` ```json { "state": [ 'declined', 'paid', 'pending', ], "fulfillment": [ 'complete', 'partial', 'unfulfilled', ] } ``` -------------------------------- ### Publish Package Configuration Source: https://github.com/spatie/laravel-model-states/blob/main/README.md Publishes the package's configuration file to your Laravel project. This allows customization of default settings, such as the default transition class. ```bash php artisan vendor:publish --provider="Spatie\ModelStates\ModelStatesServiceProvider" --tag="model-states-config" ``` -------------------------------- ### Create Payment Instance Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/02-serializing-states.md Demonstrates the basic creation of a new payment model instance. ```php PaymentState::class, ]; } ``` -------------------------------- ### Configure State Defaults and Transitions Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/01-configuring-states.md Sets up initial state configurations within the abstract state class's `config` method. This includes defining a default state and specifying allowed transitions between states. ```php use Spatie\ModelStates\State; use Spatie\ModelStates\StateConfig; abstract class PaymentState extends State { abstract public function color(): string; public static function config(): StateConfig { return parent::config() ->default(Pending::class) ->allowTransition(Pending::class, Paid::class) ->allowTransition(Pending::class, Failed::class) ; } } ``` -------------------------------- ### Default Package Configuration Source: https://github.com/spatie/laravel-model-states/blob/main/README.md The content of the published configuration file for the model states package. It specifies the default transition class to be used. ```php return [ /* * The fully qualified class name of the default transition. */ 'default_transition' => Spatie\ModelStates\DefaultTransition::class, ]; ``` -------------------------------- ### Use State Transitions Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/01-configuring-transitions.md Demonstrates how to initiate a state transition on a model instance. The transition will only succeed if it has been explicitly allowed in the state configuration. ```php $payment->state->transitionTo(Paid::class); ``` -------------------------------- ### Get Registered States for Specific Column Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/03-listing-states.md Retrieves registered state classes for a particular column, using the `Invoice::getStatesFor('columnName')` method. This is useful for inspecting states related to a single attribute. ```php Invoice::getStatesFor('state') ``` ```json [ 'declined', 'paid', 'pending', ] ``` -------------------------------- ### Get Default State for Specific Column Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/03-listing-states.md Retrieves the default state class for a particular column, using the `Invoice::getDefaultStateFor('columnName')` method. This returns the specific default state class for a given attribute. ```php Invoice::getDefaultStateFor('state') ``` ```json 'App\States\Invoice\Pending' ``` -------------------------------- ### Configure Simple and Custom Transitions Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/01-configuring-transitions.md Defines allowed transitions between states, including options for simple transitions and custom transition classes. This ensures state changes are structured and safe. ```php abstract class PaymentState extends State { // … public static function config(): StateConfig { return parent::config() ->allowTransition(Pending::class, Paid::class) ->allowTransition(Pending::class, Failed::class, PendingToFailed::class); } } ``` -------------------------------- ### State Resolution Directory Structure Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/02-serializing-states.md Provides the recommended directory structure for states, where the abstract state class automatically detects and resolves concrete implementations. ```text States/ ├── Failed.php ├── Paid.php ├── PaymentState.php // This abstract class will automatically detect all relevant states within this directory. └── Pending.php ``` -------------------------------- ### Configuring Transitions in State Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/02-custom-transition-classes.md Demonstrates how to configure allowed transitions within a state class using the `config()` method. It specifically shows how to allow a transition from the `Pending` state to the `Failed` state using the custom `PendingToFailed` transition class. ```php abstract class PaymentState extends State { // … public static function config(): StateConfig { return parent::config() ->allowTransition(Pending::class, Failed::class, PendingToFailed::class); } } ``` -------------------------------- ### Define Abstract State Class Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/01-configuring-states.md Creates an abstract base class for your states, extending `Spatie\ModelStates\State`. This class can define common methods and abstract methods that concrete states must implement, such as `color()`. ```php use Spatie\ModelStates\State; /** * @extends State<\App\Models\Payment> */ abstract class PaymentState extends State { abstract public function color(): string; } ``` -------------------------------- ### Allow Multiple Transitions at Once Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/01-configuring-transitions.md Provides a shorthand method `allowTransitions` to configure multiple distinct transitions in a single call. This improves readability for complex state configurations. ```php abstract class PaymentState extends State { // … public static function config(): StateConfig { return parent::config() ->allowTransitions([ [Pending::class, Paid::class], [Pending::class, Failed::class, PendingToFailed::class], ]); } } ``` -------------------------------- ### Using Direct Transition Class Instance Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/02-custom-transition-classes.md Shows an alternative method for triggering transitions by directly instantiating and passing a custom transition class to the `transition` method. This approach can improve IDE autocompletion and is useful for complex transitions. ```php $payment->state->transition(new CreatedToFailed($payment, 'error message')); ``` -------------------------------- ### Using `transitionTo` with Arguments Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/02-custom-transition-classes.md Illustrates how to trigger a state transition using the `transitionTo` method on the current state object. This method accepts the target state class and any additional arguments, which are then passed to the transition class's constructor. ```php $payment->state->transitionTo(Failed::class, 'error message'); ``` -------------------------------- ### Allow Multiple From States Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/01-configuring-transitions.md Enables defining multiple source states that can transition to a single target state within one `allowTransition` call. This streamlines configurations where several states lead to the same outcome. ```php abstract class PaymentState extends State { // … public static function config(): StateConfig { return parent::config() ->allowTransition([Created::class, Pending::class], Failed::class, ToFailed::class); } } ``` -------------------------------- ### Implement Concrete State Class Source: https://github.com/spatie/laravel-model-states/blob/main/README.md A concrete implementation of a state (`Paid`) extending the abstract `PaymentState`. It provides the specific logic for the `color` method. ```php class Paid extends PaymentState { public function color(): string { return 'green'; } } ``` -------------------------------- ### Implement Concrete State Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/01-configuring-states.md Provides a concrete implementation of an abstract state class. Each concrete state represents a specific status for your model and must implement any abstract methods defined in the base state class. ```php class Paid extends PaymentState { public function color(): string { return 'green'; } } ``` -------------------------------- ### Allow All Transitions Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/01-configuring-transitions.md Configures the state to permit transitions between any registered states. This is a convenient shortcut when all state transitions are valid. ```php abstract class PaymentState extends State { // … public static function config(): StateConfig { return parent::config() ->allowAllTransitions(); } } ``` -------------------------------- ### Configure Laravel Model States with PHP Attributes Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/01-configuring-states.md Demonstrates how to configure state transitions and registration for a model state using PHP 8 attributes. It showcases attributes like `AllowTransition`, `DefaultState`, and `RegisterState` to define state behavior and relationships within an abstract state class. ```PHP use Spatie\ModelStates\Attributes\AllowTransition; use Spatie\ModelStates\Attributes\RegisterState; use Spatie\ModelStates\State; #[ AllowTransition(Pending::class, Paid::class), AllowTransition(Pending::class, Failed::class), DefaultState(Pending::class), RegisterState(Cancelled::class), RegisterState([ExampleOne::class, ExampleTwo::class]), ] abstract class PaymentState extends State { abstract public function color(): string; } ``` -------------------------------- ### Manually Register States Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/01-configuring-states.md Allows for explicit registration of concrete state classes within the `config` method, especially useful when states are located in custom directories or when you need fine-grained control over registration. ```php use Spatie\ModelStates\State; use Spatie\ModelStates\StateConfig; use Your\Concrete\State\Class\Cancelled; use Your\Concrete\State\Class\ExampleOne; use Your\Concrete\State\Class\ExampleTwo; abstract class PaymentState extends State { abstract public function color(): string; public static function config(): StateConfig { return parent::config() ->default(Pending::class) ->allowTransition(Pending::class, Paid::class) ->allowTransition(Pending::class, Failed::class) ->registerState(Cancelled::class) ->registerState([ExampleOne::class, ExampleTwo::class]) ; } } ``` -------------------------------- ### Concrete Paid State Implementation (PHP) Source: https://github.com/spatie/laravel-model-states/blob/main/docs/01-introduction.md This snippet provides a concrete implementation of a specific state, 'Paid', extending the abstract state class. It implements the abstract method `color()` to return a state-specific value. ```php class Paid extends PaymentState { public function color(): string { return 'green'; } } ``` -------------------------------- ### Implement HasStatesContract for Type-Hinting in Laravel Models Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/01-configuring-states.md Shows how to implement the `HasStatesContract` interface and use the `HasStates` trait within a Laravel Eloquent model. This integration provides improved type-hinting, allowing direct interaction with state objects rather than their string representations. ```PHP use Spatie\ModelStates\HasStates; use Spatie\ModelStates\HasStatesContract; class Payment extends Model implements HasStatesContract { use HasStates; // … } ``` -------------------------------- ### Retrieve Transitionable State Instances Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/04-retrieving-transitionable-states.md Retrieves an array of instantiated state objects that can be transitioned to from the current state. This allows direct access to state methods and properties. ```php $stateInstances = $payment->state->transitionableStateInstances(); // Example Output: // [ // 0 => Paid { // // State instance with model reference // } // ] ``` -------------------------------- ### Create Payment with Specific State Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/02-serializing-states.md Illustrates creating a payment and assigning a specific state using its class reference, which will be serialized using its custom name. ```php Paid::class, ]); ``` -------------------------------- ### Create Custom Default Transition Class Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/06-custom-default-transition-class.md Extends `Spatie\ModelStates\DefaultTransition` to add custom constructor parameters, such as a `silent` flag. This allows for passing specific data during the transition process. ```PHP use Spatie\ModelStates\DefaultTransition; use Spatie\ModelStates\State; class CustomDefaultTransitionWithAttributes extends DefaultTransition { public function __construct($model, string $field, State $newState, public bool $silent = false) { parent::__construct($model, $field, $newState); } } ``` -------------------------------- ### Custom Transition Class Implementation Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/02-custom-transition-classes.md Defines a custom transition class that extends `Spatie\ModelStates\Transition`. This class handles the logic for transitioning a payment from 'pending' to 'failed', including updating the model's state, setting timestamps, and saving an error message. ```php use Spatie\ModelStates\Transition; class PendingToFailed extends Transition { private Payment $payment; private string $message; public function __construct(Payment $payment, string $message) { $this->payment = $payment; $this->message = $message; } public function handle(): Payment { $this->payment->state = new Failed($this->payment); $this->payment->failed_at = now(); $this->payment->error_message = $this->message; $this->payment->save(); return $this->payment; } } ``` -------------------------------- ### State Transition Method Signature Source: https://github.com/spatie/laravel-model-states/blob/main/UPGRADING.md Compares the method signature for checking state transitions before and after the v2 update. v2 simplifies the call by associating states directly with model fields, removing the need to pass the field name explicitly. ```php $model->canTransitionTo(StateB::class, 'status'); ``` ```php $model->status->canTransitionTo(StateB::class); ``` -------------------------------- ### Display Transitionable States in Blade Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/04-retrieving-transitionable-states.md Iterates over transitionable state instances in a Blade template to display state properties like color, label, and icon. This leverages the state instances retrieved via `transitionableStateInstances()`. ```blade @foreach($payment->state->transitionableStateInstances() as $stateInstance)
{{ $stateInstance->label() }}
@endforeach ``` -------------------------------- ### Inject Dependencies in Laravel Model States Transition Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/03-dependency-injection-in-transition-classes.md This snippet shows how to inject dependencies directly into the `handle()` method of a custom transition class. Dependencies are automatically resolved from Laravel's service container. Be mindful of excessive side effects or dependencies, as refactoring to an event-based system might be more appropriate. ```PHP class TransitionWithDependency extends TransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransitionTransition ``` -------------------------------- ### Define Abstract State Class Source: https://github.com/spatie/laravel-model-states/blob/main/README.md Defines an abstract base class for states (`PaymentState`). It enforces an abstract `color` method and configures allowed state transitions using `StateConfig`. ```php use Spatie\ModelStates\State; use Spatie\ModelStates\StateConfig; abstract class PaymentState extends State { abstract public function color(): string; public static function config(): StateConfig { return parent::config() ->default(Pending::class) ->allowTransition(Pending::class, Paid::class) ->allowTransition(Pending::class, Failed::class) ; } } ``` -------------------------------- ### Retrieve Transitionable States Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/04-retrieving-transitionable-states.md Retrieves an array of string representations for states that can be transitioned to from the current state. This method returns state names. ```php $transitionableStates = $payment->state->transitionableStates(); // Example Output: // [ // 0 => "paid" // ] ``` -------------------------------- ### Add State Field to Database Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/01-configuring-states.md Defines the database schema for state management by adding a string column to your model's table. This column will store the serialized state. ```php Schema::table('payments', function (Blueprint $table) { $table->string('state'); }); ``` -------------------------------- ### Ignore Same State Transitions with Attribute Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/01-configuring-transitions.md Applies the `#[IgnoreSameState]` attribute to a state class to automatically allow transitions to the current state. This simplifies configuration for common scenarios. ```php #[IgnoreSameState] abstract class PaymentState extends State { //... } ``` -------------------------------- ### Define Payment Model with States (PHP) Source: https://github.com/spatie/laravel-model-states/blob/main/docs/01-introduction.md This snippet shows how to define a Laravel Eloquent model that utilizes the spatie/laravel-model-states package. It demonstrates using the `HasStates` trait and casting a model attribute to a custom state class. ```php use Spatie\ModelStates\HasStates; class Payment extends Model { use HasStates; protected $casts = [ 'state' => PaymentState::class, ]; } ``` -------------------------------- ### Conditional Transitions with `canTransition` Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/02-custom-transition-classes.md Explains how to implement the `canTransition` method within a custom transition class to enforce specific conditions before a transition can occur. If `canTransition` returns `false`, a `TransitionNotAllowed` exception is thrown. ```php class CreatedToFailed extends Transition { // … public function canTransition(): bool { return $this->payment->state->equals(Created::class); } } ``` -------------------------------- ### Check for Available Transitions Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/04-retrieving-transitionable-states.md Determines if there are any available transitions from the current state. Returns a boolean value indicating whether transitions are possible. ```php $hasTransitions = $payment->state->hasTransitionableStates(); // true or false ``` -------------------------------- ### Register Custom StateChanged Event Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-states/01-configuring-states.md Allows you to specify a custom event that will be dispatched whenever a model's state changes. This provides flexibility for custom event handling and listeners. ```php use Spatie\ModelStates\State; use Spatie\ModelStates\StateConfig; use Your\Concrete\State\Event\CustomStateChanged; abstract class PaymentState extends State { abstract public function color(): string; public static function config(): StateConfig { return parent::config() ->stateChangedEvent(CustomStateChanged::class) ; } } ``` -------------------------------- ### Pass Custom Parameter to transitionTo Method Source: https://github.com/spatie/laravel-model-states/blob/main/docs/working-with-transitions/06-custom-default-transition-class.md Demonstrates how to pass custom parameters, such as a boolean `silent` flag, to the `transitionTo` method. This allows control over the behavior of subsequent event listeners, like skipping notifications. ```PHP class OrderService { public function markAsPaid(Order $order): void { // Will trigger notification $order->state->transitionTo(PaidState::class); // Also can be specified explicitly $order->state->transitionTo(PaidState::class, false); } public function markAsPaidSilently(Order $order): void { // Will not trigger notification $order->state->transitionTo(PaidState::class, true); } } ```