ArchTech Enums

https://github.com/archtechx/enums
Admin
ArchTech Enums is a PHP library that provides a collection of traits and helpers to make working...
Tokens:27,080
Snippets:334
Trust Score:9.6
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### Complete metadata implementation example

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/meta.md

A full example demonstrating custom MetaProperty classes, default values, and metadata access.

```php
use ArchTech
epEnums\Metadata;
use ArchTech
epEnums\Meta\Meta;
use ArchTech
epEnums\Meta\MetaProperty;
use Attribute;

// Define metadata properties
#[Attribute]
class Label extends MetaProperty
{
    protected function transform(mixed $value): mixed
    {
        return strtoupper($value);
    }
}

#[Attribute]
class Icon extends MetaProperty
{
}

#[Attribute]
class Color extends MetaProperty
{
    public static function defaultValue(): mixed
    {
        return 'gray';
    }
}

#[Attribute]
class Priority extends MetaProperty
{
}

// Declare all properties with Meta
#[Meta(Label::class, Icon::class, Color::class, Priority::class)]
enum NotificationStatus: string
{
    use Metadata;

    #[Label('success')] #[Icon('check')] #[Color('green')] #[Priority(1)]
    case SUCCESS = 'success';

    #[Label('warning')] #[Icon('alert')] #[Color('yellow')] #[Priority(2)]
    case WARNING = 'warning';

    #[Label('error')] #[Icon('x')] #[Color('red')] #[Priority(3)]
    case ERROR = 'error';

    #[Label('info')] #[Icon('info')] #[Priority(0)]
    case INFO = 'info';
}

// Access metadata
echo NotificationStatus::SUCCESS->label();    // SUCCESS
echo NotificationStatus::SUCCESS->icon();     // check
echo NotificationStatus::SUCCESS->color();    // green
echo NotificationStatus::SUCCESS->priority(); // 1

echo NotificationStatus::INFO->color();       // gray (default)
```

--------------------------------

### Quick Start Enum Implementation

Source: https://github.com/archtechx/enums/blob/master/_autodocs/00-START-HERE.md

Demonstrates basic usage of InvokableCases, Names, and Values traits within a PHP enum.

```php
use ArchTech\Enums\InvokableCases;
use ArchTech\Enums\Names;
use ArchTech\Enums\Values;

enum TaskStatus: int
{
    use InvokableCases, Names, Values;

    case PENDING = 1;
    case ACTIVE = 2;
    case COMPLETED = 3;
}

// Invoke cases as methods
TaskStatus::PENDING();          // Returns: 1
$status = TaskStatus::PENDING;
$value = $status();             // Also returns: 1

// Get all names or values
TaskStatus::names();            // ['PENDING', 'ACTIVE', 'COMPLETED']
TaskStatus::values();           // [1, 2, 3]
```

--------------------------------

### Implement and use a custom MetaProperty

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/meta-property.md

Example showing how to extend MetaProperty to create a custom attribute and apply it to an enum case.

```php
use ArchTech\Enums\Meta\MetaProperty;
use Attribute;

#[Attribute]
class Priority extends MetaProperty
{
}

$prop = new Priority(5);
echo $prop->value; // 5

// Via attribute syntax
#[Priority(3)]
case MEDIUM = 2;
```

--------------------------------

### Direct Reflection Usage

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/reflection.md

Advanced usage examples for retrieving metadata properties and values directly from enum instances.

```php
use ArchTech\Enums\Meta\Reflection;
use ArchTech\Enums\Metadata;

#[Meta(Color::class)]
enum Status: int
{
    use Metadata;

    #[Color('red')]
    case ERROR = 1;

    #[Color('green')]
    case SUCCESS = 2;
}

// Get all metadata properties for an enum instance
$status = Status::ERROR;
$properties = Reflection::metaProperties($status);
// Returns: ['Color']

// Get specific metadata value
$color = Reflection::metaValue(Color::class, $status);
// Returns: 'red'

// Get all colors for all cases
foreach (Status::cases() as $case) {
    $color = Reflection::metaValue(Color::class, $case);
    echo "{$case->name}: {$color}\n";
}
```

--------------------------------

### Install ArchTech Enums via Composer

Source: https://github.com/archtechx/enums/blob/master/_autodocs/README.md

Use this command to add the library to your project dependencies.

```bash
composer require archtechx/enums
```

--------------------------------

### Define and use custom MetaProperty attributes

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/meta-property.md

Create custom metadata attributes by extending MetaProperty and applying them to enum cases. This example demonstrates transformation, default values, and custom method mapping.

```php
use ArchTech\...Enums\Metadata;
use ArchTech\Enums\Meta\Meta;
use ArchTech\Enums\Meta\MetaProperty;
use Attribute;

// Define custom metadata properties
#[Attribute]
class Label extends MetaProperty
{
    protected function transform(mixed $value): mixed
    {
        // Capitalize labels
        return ucfirst(strtolower($value));
    }
}

#[Attribute]
class CSSClass extends MetaProperty
{
    protected function transform(mixed $value): mixed
    {
        // Ensure proper CSS class format
        return trim($value);
    }

    public static function defaultValue(): mixed
    {
        return 'btn-default';
    }
}

#[Attribute]
class Shortcut extends MetaProperty
{
    public static function method(): string
    {
        return 'getKeybinding';
    }
}

// Use in enum
#[Meta(Label::class, CSSClass::class, Shortcut::class)]
enum ButtonType: string
{
    use Metadata;

    #[Label('SAVE')] #[CSSClass('btn-success')] #[Shortcut('Ctrl+S')]
    case PRIMARY = 'primary';

    #[Label('CANCEL')] #[CSSClass('btn-danger')] #[Shortcut('Esc')]
    case SECONDARY = 'secondary';

    #[Label('DELETE')] #[Shortcut('Ctrl+D')]
    case DANGER = 'danger';
}

// Access metadata
echo ButtonType::PRIMARY->label();        // 'Save'
echo ButtonType::PRIMARY->cssclass();     // 'btn-success'
echo ButtonType::PRIMARY->getKeybinding(); // 'Ctrl+S'

echo ButtonType::DANGER->label();        // 'Delete'
echo ButtonType::DANGER->cssclass();     // 'btn-default' (default)
echo ButtonType::DANGER->getKeybinding(); // 'Ctrl+D'
```

--------------------------------

### Common Use Cases for Invokable Enums

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/invokable-cases.md

Examples of using invoked enums as array keys, database parameters, and method arguments.

```php
$config = [
    TaskStatus::INCOMPLETE() => ['color' => 'red'],
    TaskStatus::COMPLETED() => ['color' => 'green'],
];

$db->update('tasks', ['status' => $status()], ['id' => $taskId]);

$this->validateStatus(TaskStatus::COMPLETED());
```

--------------------------------

### Create MetaProperty instance with make()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/meta-property.md

Demonstrates creating a new MetaProperty instance using the static make() method.

```php
use ArchTech\Enums\Meta\MetaProperty;
use Attribute;

#[Attribute]
class Color extends MetaProperty
{
}

$redColor = Color::make('red');
// Equivalent to: new Color('red')

// Use with fromMeta()
$status = Status::fromMeta(Color::make('green'));
```

--------------------------------

### Triggering UndefinedCaseError via Typo

Source: https://github.com/archtechx/enums/blob/master/_autodocs/errors.md

Example of triggering the error due to a misspelled case name.

```php
TaskStatus::COMPLTED(); // Should be COMPLETED
// Throws: UndefinedCaseError
```

--------------------------------

### Triggering UndefinedCaseError via Invalid Invocation

Source: https://github.com/archtechx/enums/blob/master/_autodocs/errors.md

Example of triggering the error by calling a non-existent enum case.

```php
enum TaskStatus: int
{
    use InvokableCases;
    case PENDING = 1;
}

TaskStatus::INVALID(); // Throws UndefinedCaseError
```

--------------------------------

### Permission System Implementation

Source: https://github.com/archtechx/enums/blob/master/_autodocs/trait-combinations.md

Shows how to use traits to enable permission checking and listing of enum names.

```php
use ArchTech\Enums\Comparable;
use ArchTech\Enums\InvokableCases;
use ArchTech\Enums\Names;
use ArchTech\Enums\From;

enum Permission: string
{
    use InvokableCases, Names, From, Comparable;

    case CREATE = 'create';
    case READ = 'read';
    case UPDATE = 'update';
    case DELETE = 'delete';
    case ADMIN = 'admin';
}

// Check permission
if ($userPermission->in([Permission::ADMIN])) {
    // Allow all operations
}

// List all permissions
$availablePermissions = Permission::names();
```

--------------------------------

### Implement State Machine with Metadata

Source: https://github.com/archtechx/enums/blob/master/_autodocs/trait-combinations.md

Uses Metadata, Comparable, and From traits to define valid state transitions via custom attributes.

```php
use ArchTech
Enums
Metadata;
use ArchTech
Enums
Meta
Meta;
use ArchTech
Enums
Meta
MetaProperty;
use ArchTech
Enums
Comparable;
use ArchTech
Enums
From;
use Attribute;

#[Attribute]
class TransitionsTo extends MetaProperty {
    public static function method(): string {
        return 'transitions';
    }
}

#[Meta(TransitionsTo::class)]
enum WorkflowState: string
{
    use Metadata, Comparable, From;

    #[TransitionsTo(['active'])]
    case DRAFT = 'draft';

    #[TransitionsTo(['completed', 'archived'])]
    case ACTIVE = 'active';

    #[TransitionsTo(['draft'])]
    case COMPLETED = 'completed';

    #[TransitionsTo([])]
    case ARCHIVED = 'archived';
}

// Check valid transitions
$currentState = WorkflowState::ACTIVE;
$nextState = WorkflowState::COMPLETED;

$validTransitions = $currentState->transitions() ?? [];
if ($nextState->is($nextState) || in_array($nextState->value, $validTransitions)) {
    // Transition is valid
}
```

--------------------------------

### Use fromMeta() and tryFromMeta()

Source: https://github.com/archtechx/enums/blob/master/README.md

Lookup enum cases based on their metadata values.

```php
TaskStatus::fromMeta(Color::make('green')); // TaskStatus::COMPLETED
TaskStatus::fromMeta(Color::make('blue')); // Error: ValueError
```

```php
TaskStatus::tryFromMeta(Color::make('green')); // TaskStatus::COMPLETED
TaskStatus::tryFromMeta(Color::make('blue')); // null
```

--------------------------------

### Constructor signature for Meta

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/meta.md

The constructor accepts a variable list of MetaProperty class names or a single array.

```php
public function __construct(array|string ...$metaProperties)
```

--------------------------------

### Project Directory Structure

Source: https://github.com/archtechx/enums/blob/master/_autodocs/MANIFEST.md

Displays the file hierarchy for the project documentation located in the output directory.

```text
output/
├── README.md                    ← Start here
├── DOCUMENTATION_INDEX.md       ← Navigation guide
├── MANIFEST.md                  ← This file
├── api-export-index.md
├── errors.md
├── trait-combinations.md
└── api-reference/
    ├── invokable-cases.md
    ├── names.md
    ├── values.md
    ├── options.md
    ├── from.md
    ├── comparable.md
    ├── metadata.md
    ├── meta.md
    ├── meta-property.md
    └── reflection.md
```

--------------------------------

### Import ArchTech Enums Classes and Traits

Source: https://github.com/archtechx/enums/blob/master/_autodocs/README.md

Reference the available traits, metadata classes, and exceptions provided by the ArchTech\Enums namespace.

```php
// Main traits (apply these to your enums)
use ArchTech
Enums\InvokableCases;
use ArchTech
Enums\Names;
use ArchTech
Enums\Values;
use ArchTech
Enums\Options;
use ArchTech
Enums\From;
use ArchTech
Enums\Comparable;
use ArchTech
Enums\Metadata;

// Metadata support classes
use ArchTech
Enums\Meta\Meta;
use ArchTech
Enums\Meta\MetaProperty;
use ArchTech
Enums\Meta\Reflection;

// Exceptions
use ArchTech
Enums\Exceptions\UndefinedCaseError;
```

--------------------------------

### Importing All Available Enums Features

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-export-index.md

Includes all traits, metadata classes, and the UndefinedCaseError exception.

```php
use ArchTech\Enums\InvokableCases;
use ArchTech\Enums\Names;
use ArchTech\Enums\Values;
use ArchTech\Enums\Options;
use ArchTech\Enums\From;
use ArchTech\Enums\Comparable;
use ArchTech\Enums\Metadata;
use ArchTech\Enums\Meta\Meta;
use ArchTech\Enums\Meta\MetaProperty;
use ArchTech\Enums\Exceptions\UndefinedCaseError;
```

--------------------------------

### Implement tryFromMeta Method

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/reflection.md

Internal implementation of tryFromMeta using reflection to match enum cases against metadata values.

```php
// From Metadata.php
public static function tryFromMeta(MetaProperty $metaProperty): static|null
{
    foreach (static::cases() as $case) {
        if (Meta\Reflection::metaValue($metaProperty::class, $case) === $metaProperty->value) {
            return $case;
        }
    }
    return null;
}
```

--------------------------------

### Catching ValueError and Using try Methods

Source: https://github.com/archtechx/enums/blob/master/_autodocs/errors.md

Illustrates how to catch ValueError exceptions and the alternative use of tryFromName to return null instead of throwing an exception.

```php
use ArchTech
Enums\From;

enum TaskStatus: int
{
	use From;
	case PENDING = 1;
}

try {
	$status = TaskStatus::fromName('INVALID');
} catch (ValueError $e) {
	echo "Error: " . $e->getMessage();
}

// Use tryFromName() to avoid exceptions
$status = TaskStatus::tryFromName('INVALID'); // Returns null
if ($status === null) {
	echo "Invalid status";
}
```

--------------------------------

### Manage Configuration Enums

Source: https://github.com/archtechx/enums/blob/master/_autodocs/trait-combinations.md

Combines InvokableCases, Names, Values, Options, and From traits for streamlined configuration handling and validation.

```php
use ArchTech
Enums
InvokableCases;
use ArchTech
Enums
Names;
use ArchTech
Enums
Values;
use ArchTech
Enums
Options;
use ArchTech
Enums
From;

enum Environment: string
{
    use InvokableCases, Names, Values, Options, From;

    case DEVELOPMENT = 'development';
    case STAGING = 'staging';
    case PRODUCTION = 'production';
}

// In config files
'allowed_environments' => Environment::values(),

// Runtime environment selection
$env = Environment::tryFrom(env('APP_ENV')) ?? Environment::DEVELOPMENT;

// Validation
if (!Environment::values()->contains(request('env'))) {
    throw new InvalidArgumentException('Invalid environment');
}
```

--------------------------------

### Generate default HTML options

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/options.md

Demonstrates generating HTML <option> tags for backed and pure enums using the default formatter.

```php
use ArchTech
Enums
Options;

enum TaskStatus: int
{
    use Options;

    case INCOMPLETE = 0;
    case COMPLETED = 1;
    case CANCELED = 2;
}

TaskStatus::stringOptions();
// Returns:
// <option value="0">Incomplete</option>
// <option value="1">Completed</option>
// <option value="2">Canceled</option>

enum Role
{
    use Options;

    case ADMINISTRATOR;
    case SUBSCRIBER;
    case GUEST;
}

Role::stringOptions();
// Returns:
// <option value="ADMINISTRATOR">Administrator</option>
// <option value="SUBSCRIBER">Subscriber</option>
// <option value="GUEST">Guest</option>
```

--------------------------------

### Project File Structure

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-export-index.md

Directory layout of the source files and exported symbols.

```text
src/
├── InvokableCases.php          (trait)
├── Names.php                   (trait)
├── Values.php                  (trait)
├── Options.php                 (trait)
├── From.php                    (trait)
├── Comparable.php              (trait)
├── Metadata.php                (trait)
├── Meta/
│   ├── Meta.php                (attribute class)
│   ├── MetaProperty.php        (base class)
│   └── Reflection.php          (utility class)
├── Exceptions/
│   └── UndefinedCaseError.php  (exception class)
└── PHPStan/
    └── InvokableCases/
        ├── ReflectionExtension.php
        └── StaticInvokableCaseMethodReflection.php
```

--------------------------------

### Use fromName with Backed and Pure Enums

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/from.md

Demonstrates retrieving enum instances by name regardless of whether the enum is backed or pure.

```php
use ArchTech\Enums\From;

enum TaskStatus: int
{
    use From;

    case INCOMPLETE = 0;
    case COMPLETED = 1;
    case CANCELED = 2;
}

TaskStatus::fromName('INCOMPLETE'); // Returns: TaskStatus::INCOMPLETE
TaskStatus::fromName('COMPLETED');  // Returns: TaskStatus::COMPLETED
TaskStatus::fromName('MISSING');    // Throws: ValueError
```

```php
use ArchTech\Enums\From;

enum Role
{
    use From;

    case ADMINISTRATOR;
    case SUBSCRIBER;
}

Role::fromName('ADMINISTRATOR'); // Returns: Role::ADMINISTRATOR
Role::fromName('INVALID');       // Throws: ValueError
```

--------------------------------

### make()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/meta-property.md

Creates a new instance of the MetaProperty with the given value.

```APIDOC
## static make(mixed $value)

### Description
Creates a new instance of the MetaProperty with the given value.

### Parameters
- **$value** (mixed) - Required - The metadata value

### Return Type
- **static** - A new instance of the MetaProperty
```

--------------------------------

### Use tryFromName with Enums

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/from.md

Demonstrates safe retrieval of enum instances by name for both backed and pure enums.

```php
use ArchTech\Enums\From;

enum TaskStatus: int
{
    use From;

    case INCOMPLETE = 0;
    case COMPLETED = 1;
}

TaskStatus::tryFromName('COMPLETED'); // Returns: TaskStatus::COMPLETED
TaskStatus::tryFromName('NOTHING');   // Returns: null

enum Role
{
    use From;

    case ADMINISTRATOR;
    case GUEST;
}

Role::tryFromName('GUEST');    // Returns: Role::GUEST
Role::tryFromName('TESTER');   // Returns: null
```

--------------------------------

### Retrieve Backed Enum Options

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/options.md

Use the options() method on backed enums to return an associative array mapping case names to their values.

```php
use ArchTech\Enums\Options;

enum TaskStatus: int
{
    use Options;

    case INCOMPLETE = 0;
    case COMPLETED = 1;
    case CANCELED = 2;
}

TaskStatus::options();
// Returns: ['INCOMPLETE' => 0, 'COMPLETED' => 1, 'CANCELED' => 2]

enum Priority: string
{
    use Options;

    case LOW = 'low';
    case MEDIUM = 'medium';
    case HIGH = 'high';
}

Priority::options();
// Returns: ['LOW' => 'low', 'MEDIUM' => 'medium', 'HIGH' => 'high']
```

--------------------------------

### Generate Configuration Maps

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/options.md

Customizes string output using a callback to format enum names and values.

```php
$statusColors = TaskStatus::stringOptions(
    fn ($name, $value) => "'$value' => 'color-$name'",
    ', '
);
// Use in config file generation
```

--------------------------------

### Migrating Enums to Use Traits

Source: https://github.com/archtechx/enums/blob/master/_autodocs/trait-combinations.md

Demonstrates the transition from a standard PHP enum to one utilizing multiple ArchTech traits without breaking existing functionality.

```php
// Before
enum Status {
    case PENDING;
    case ACTIVE;
}

// After: Add traits gradually
enum Status {
    use InvokableCases; // Add invokability first
    use Names;          // Add collection support
    use From;           // Add conversion
    use Comparable;     // Add comparisons

    case PENDING;
    case ACTIVE;
}

// No breaking changes - existing code still works
```

--------------------------------

### Attribute Instantiation Logic

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/reflection.md

Internal methods for extracting and instantiating Meta attributes from reflection objects.

```php
// From parseMetaProperties()
$attributes = $reflection->getAttributes(Meta::class);
$meta = $attributes[0]->newInstance();
return $meta->metaProperties;

// From metaValue()
$attributes = $reflection->getAttributes();
$properties = array_map(fn (ReflectionAttribute $attr) => $attr->newInstance(), $attributes);
```

--------------------------------

### Use the from() method

Source: https://github.com/archtechx/enums/blob/master/README.md

Retrieve an enum case by its value or name.

```php
Role::from('ADMINISTRATOR'); // Role::ADMINISTRATOR
Role::from('NOBODY'); // Error: ValueError
```

--------------------------------

### Implement Basic Enum Helpers

Source: https://github.com/archtechx/enums/blob/master/_autodocs/README.md

Use traits to enable static invocation, name/value retrieval, options formatting, and name-based instance lookup.

```php
use ArchTech\Enums\InvokableCases;
use ArchTech\Enums\Names;
use ArchTech\Enums\Values;
use ArchTech\Enums\Options;
use ArchTech\Enums\From;

enum TaskStatus: int
{
    use InvokableCases, Names, Values, Options, From;

    case PENDING = 1;
    case ACTIVE = 2;
    case COMPLETED = 3;
}

// Invokable cases
TaskStatus::PENDING();           // Returns: 1
TaskStatus::ACTIVE();            // Returns: 2

// Names and values
TaskStatus::names();             // ['PENDING', 'ACTIVE', 'COMPLETED']
TaskStatus::values();            // [1, 2, 3]

// Options
TaskStatus::options();           // ['PENDING' => 1, 'ACTIVE' => 2, 'COMPLETED' => 3]
TaskStatus::stringOptions();     // HTML option tags

// From names
TaskStatus::fromName('PENDING'); // Returns: TaskStatus::PENDING
TaskStatus::tryFromName('NONE'); // Returns: null
```

--------------------------------

### Safe Metadata Lookup

Source: https://github.com/archtechx/enums/blob/master/_autodocs/errors.md

Prefer tryFromMeta() over fromMeta() to handle missing metadata gracefully without triggering a ValueError.

```php
use ArchTech
Enums
Metadata;
use ArchTech
Enums
Meta
Meta;

#[Meta(Color::class)]
enum Badge: int
{
    use Metadata;
    #[Color('red')]
    case ERROR = 1;
}

// Risky
try {
    $badge = Badge::fromMeta(Color::make('unknown'));
} catch (ValueError $e) {
    log_error($e);
}

// Safer
$badge = Badge::tryFromMeta(Color::make('unknown'));
if ($badge === null) {
    log_warning("Badge not found for color");
}
```

--------------------------------

### Documentation File Structure

Source: https://github.com/archtechx/enums/blob/master/_autodocs/00-START-HERE.md

Visual representation of the documentation directory layout.

```text
/output/
├── 00-START-HERE.md              ← You are here
├── README.md                     ← Read this next
├── DOCUMENTATION_INDEX.md        ← Navigation guide
├── MANIFEST.md                   ← What's included
├── api-export-index.md           ← All exported symbols
├── errors.md                     ← Exception reference
├── trait-combinations.md         ← How to combine traits
└── api-reference/                ← Individual trait/class docs
    ├── invokable-cases.md
    ├── names.md
    ├── values.md
    ├── options.md
    ├── from.md
    ├── comparable.md
    ├── metadata.md
    ├── meta.md
    ├── meta-property.md
    └── reflection.md
```

--------------------------------

### Create meta properties

Source: https://github.com/archtechx/enums/blob/master/README.md

Define custom meta property classes using attributes.

```php
#[Attribute]
class Color extends MetaProperty {}

#[Attribute]
class Description extends MetaProperty {}
```

--------------------------------

### Enable IDE Autocompletion for Metadata

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/metadata.md

Use PHPDoc @method annotations to provide IDE support for dynamically generated metadata accessor methods.

```php
/**
 * @method string description()
 * @method string color()
 * @method string icon()
 */
#[Meta(Description::class, Color::class, Icon::class)]
enum TaskStatus: int
{
    use Metadata;
    // ...
}
```

```php
/**
 * @method string description()
 * @method string color()
 */
trait HasDescriptionAndColor
{
}

#[Meta(Description::class, Color::class)]
enum Status
{
    use Metadata;
    use HasDescriptionAndColor;
    // ...
}
```

--------------------------------

### Comparing Native and Trait Methods

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/from.md

Distinguish between native PHP value matching and trait-based name matching.

```php
use ArchTech\Enums\From;

enum Status: int
{
    use From;

    case ACTIVE = 1;
    case INACTIVE = 0;
}

// PHP native (matched by value)
Status::from(1);         // Returns: Status::ACTIVE
Status::tryFrom(999);    // Returns: null

// This trait's methods (matched by name)
Status::fromName('ACTIVE');      // Returns: Status::ACTIVE
Status::tryFromName('ACTIVE');   // Returns: Status::ACTIVE
```

--------------------------------

### Run Local Development Checks

Source: https://github.com/archtechx/enums/blob/master/README.md

Execute the project's local check script to validate code style and quality.

```sh
./check
```

--------------------------------

### options()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/options.md

Retrieves all enum cases as an associative array. For backed enums, it returns an array of case names mapped to their values; for pure enums, it returns an indexed array of case names.

```APIDOC
## public static function options()

### Description
Retrieves all enum cases as an associative array. For backed enums, returns an associative array where keys are case names and values are case values. For pure enums, returns an indexed array of case names.

### Signature
`public static function options(): array`

### Parameters
None

### Return Type
`array`

### Example
```php
use ArchTech\Enums\Options;

enum TaskStatus: int
{
    use Options;

    case INCOMPLETE = 0;
    case COMPLETED = 1;
    case CANCELED = 2;
}

TaskStatus::options();
// Returns: ['INCOMPLETE' => 0, 'COMPLETED' => 1, 'CANCELED' => 2]
```
```

--------------------------------

### Use the tryFrom() method

Source: https://github.com/archtechx/enums/blob/master/README.md

Retrieve an enum case safely, returning null if not found.

```php
Role::tryFrom('GUEST'); // Role::GUEST
Role::tryFrom('NEVER'); // null
```

--------------------------------

### Use tryFrom with Pure Enum

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/from.md

Demonstrates safe retrieval of enum instances by name, returning null on failure.

```php
use ArchTech\Enums\From;

enum Role
{
    use From;

    case ADMINISTRATOR;
    case GUEST;
}

Role::tryFrom('ADMINISTRATOR'); // Returns: Role::ADMINISTRATOR
Role::tryFrom('INVALID');        // Returns: null
```

--------------------------------

### Importing Enum Traits for Values and Names

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-export-index.md

Use these traits to retrieve enum names, values, or options.

```php
use ArchTech\Enums\Names;
use ArchTech\Enums\Values;
use ArchTech\Enums\Options;
```

--------------------------------

### Importing Metadata Traits and Classes

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-export-index.md

Use these to define and access rich metadata on enum cases.

```php
use ArchTech\Enums\Metadata;
use ArchTech\Enums\Meta\Meta;
use ArchTech\Enums\Meta\MetaProperty;
```

--------------------------------

### Manage Workflow Transitions

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/comparable.md

Implement status-based logic using in() for sets and is() for single-value comparisons.

```php
use ArchTech\Enums\Comparable;

enum PaymentStatus
{
    use Comparable;

    case PENDING;
    case PROCESSING;
    case SUCCESS;
    case FAILED;
}

function canRetry(PaymentStatus $status): bool
{
    return $status->in([PaymentStatus::PENDING, PaymentStatus::FAILED]);
}

function canProcess(PaymentStatus $status): bool
{
    return $status->is(PaymentStatus::PENDING);
}
```

--------------------------------

### Define Meta Properties

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/metadata.md

Create attribute classes by extending the MetaProperty base class.

```php
use ArchTech\Enums\Meta\MetaProperty;
use Attribute;

#[Attribute]
class Description extends MetaProperty
{
}

#[Attribute]
class Color extends MetaProperty
{
}

#[Attribute]
class Icon extends MetaProperty
{
}
```

--------------------------------

### Using Options Trait

Source: https://github.com/archtechx/enums/blob/master/_autodocs/trait-combinations.md

Generates key-value pairs of enum names and values, or HTML option tags.

```php
enum Status: int
{
    use Options;

    case PENDING = 1;
    case ACTIVE = 2;
}

Status::options();              // ['PENDING' => 1, 'ACTIVE' => 2]
Status::stringOptions();        // HTML option tags
```

--------------------------------

### PSR-4 Autoload Configuration

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-export-index.md

Namespace and path mapping for Composer autoloading.

```text
Namespace: ArchTech\Enums
Path: src/
```

--------------------------------

### Catching UndefinedCaseError

Source: https://github.com/archtechx/enums/blob/master/_autodocs/errors.md

Demonstrates how to handle the UndefinedCaseError using a try-catch block.

```php
use ArchTech\Enums\Exceptions\UndefinedCaseError;
use ArchTech\Enums\InvokableCases;

enum TaskStatus: int
{
    use InvokableCases;
    case PENDING = 1;
    case COMPLETE = 2;
}

try {
    $value = TaskStatus::INVALID();
} catch (UndefinedCaseError $e) {
    echo "Error: " . $e->getMessage();
    // Error: Undefined constant TaskStatus::INVALID
}
```

--------------------------------

### Using InvokableCases with Backed Enums

Source: https://github.com/archtechx/enums/blob/master/_autodocs/README.md

Demonstrates how InvokableCases allows accessing the underlying value of a backed enum directly.

```php
enum Status: int { use InvokableCases; case PENDING = 1; }
Status::PENDING();  // Returns: 1 (the value)
Status::values();   // Returns: [1, 2, 3]
```

--------------------------------

### Passing variable arguments to Meta

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/meta.md

Multiple MetaProperty classes can be passed as separate arguments to the Meta attribute.

```php
use ArchTech
epEnums\Metadata;
use ArchTech
epEnums\Meta\Meta;

#[Meta(Description::class, Color::class, Icon::class, Priority::class)]
enum Status: int
{
    use Metadata;
    // ...
}
```

--------------------------------

### Retrieve Pure Enum Options

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/options.md

Use the options() method on pure enums to return an indexed array of case names.

```php
use ArchTech\Enums\Options;

enum Role
{
    use Options;

    case ADMINISTRATOR;
    case SUBSCRIBER;
    case GUEST;
}

Role::options();
// Returns: ['ADMINISTRATOR', 'SUBSCRIBER', 'GUEST']
// Equivalent to names() for pure enums
```

--------------------------------

### Use the tryFromName() method

Source: https://github.com/archtechx/enums/blob/master/README.md

Retrieve an enum case by name safely, returning null if not found.

```php
TaskStatus::tryFromName('COMPLETED'); // TaskStatus::COMPLETED
TaskStatus::tryFromName('NOTHING'); // null
Role::tryFromName('GUEST'); // Role::GUEST
Role::tryFromName('TESTER'); // null
```

--------------------------------

### Constructor signature for MetaProperty

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/meta-property.md

The final constructor signature used for initializing metadata properties.

```php
final public function __construct(
    public mixed $value,
)
```

--------------------------------

### Enum Methods Reference

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-export-index.md

A comprehensive list of public methods available for interacting with Enums, including retrieval and comparison operations.

```APIDOC
## Method Reference

### names()
Returns an array of all enum case names.

### values()
Returns an array of all enum case values.

### options()
Returns an array of options, either as key-value pairs or a list of names.

### stringOptions(?Closure $callback = null, string $glue = '\n')
Returns a string representation of options, optionally formatted via a callback.

### from(int|string $case)
Returns the enum instance for the given value or throws an error.

### tryFrom(int|string $case)
Returns the enum instance for the given value or null if not found.

### fromName(string $case)
Returns the enum instance for the given name or throws an error.

### tryFromName(string $case)
Returns the enum instance for the given name or null if not found.

### fromMeta(MetaProperty $metaProperty)
Returns the enum instance based on metadata.

### tryFromMeta(MetaProperty $metaProperty)
Returns the enum instance based on metadata or null if not found.

### is(mixed $enum)
Checks if the current instance matches the provided enum.

### isNot(mixed $enum)
Checks if the current instance does not match the provided enum.

### in(iterable $enums)
Checks if the current instance exists within the provided collection.

### notIn(iterable $enums)
Checks if the current instance does not exist within the provided collection.
```

--------------------------------

### Using From Trait

Source: https://github.com/archtechx/enums/blob/master/_autodocs/trait-combinations.md

Adds methods to retrieve enum cases by their name.

```php
enum TaskStatus
{
    use From;

    case PENDING;
    case COMPLETE;
}

TaskStatus::fromName('PENDING');       // TaskStatus::PENDING
TaskStatus::tryFromName('INVALID');    // null
```

--------------------------------

### Use the fromName() method

Source: https://github.com/archtechx/enums/blob/master/README.md

Retrieve an enum case by its name.

```php
TaskStatus::fromName('INCOMPLETE'); // TaskStatus::INCOMPLETE
TaskStatus::fromName('MISSING'); // Error: ValueError
Role::fromName('SUBSCRIBER'); // Role::SUBSCRIBER
Role::fromName('HACKER'); // Error: ValueError
```

--------------------------------

### Database Lookup with Error Handling

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/from.md

Use fromName to retrieve enum cases from database values, catching ValueError on failure.

```php
use ArchTech\Enums\From;

enum Role
{
    use From;

    case ADMIN;
    case USER;
}

try {
    $userRole = Role::fromName($databaseValue);
} catch (ValueError) {
    log_error("Invalid role in database: $databaseValue");
}
```

--------------------------------

### Library Content Summary

Source: https://github.com/archtechx/enums/blob/master/_autodocs/00-START-HERE.md

Overview of the components and features included in the archtechx/enums library.

```text
✓ 7 Traits (InvokableCases, Names, Values, Options, From, Comparable, Metadata)
✓ 4 Classes (Meta, MetaProperty, Reflection, UndefinedCaseError)
✓ 30+ Public Methods
✓ 150+ Usage Examples
✓ Complete Error Reference
✓ Integration Patterns
✓ Type Signatures
```

--------------------------------

### Using InvokableCases with Pure Enums

Source: https://github.com/archtechx/enums/blob/master/_autodocs/README.md

Demonstrates how InvokableCases returns the case name for pure enums.

```php
enum Role { use InvokableCases; case ADMIN; }
Role::ADMIN();      // Returns: 'ADMIN' (the name)
Role::values();     // Returns: ['ADMIN', ...] (same as names())
```

--------------------------------

### Defensive Programming with try/fromName()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/errors.md

Use tryFromName() as a safer alternative to fromName() to avoid ValueError exceptions when looking up enum cases by name.

```php
use ArchTech
Enums
From;

enum Priority: string
{
    use From;
    case LOW = 'low';
    case HIGH = 'high';
}

// Risky: may throw ValueError
try {
    $priority = Priority::fromName($input);
} catch (ValueError $e) {
    $priority = Priority::LOW; // Fallback
}

// Safer: returns null on failure
$priority = Priority::tryFromName($input) ?? Priority::LOW;
```

--------------------------------

### Generate custom formatted options

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/options.md

Demonstrates using a callback function to format enum options into custom string formats like key-value pairs, JSON, or database conditions.

```php
use ArchTech
Enums
Options;

enum TaskStatus: int
{
    use Options;

    case INCOMPLETE = 0;
    case COMPLETED = 1;
}

// Simple key-value format
TaskStatus::stringOptions(
    fn ($name, $value) => "$name => $value",
    ', '
);
// Returns: "INCOMPLETE => 0, COMPLETED => 1"

// JSON format
TaskStatus::stringOptions(
    fn ($name, $value) => json_encode(['name' => $name, 'value' => $value]),
    ','
);
// Returns: '{"name":"INCOMPLETE","value":0},{"name":"COMPLETED","value":1}'

// Database condition
TaskStatus::stringOptions(
    fn ($name, $value) => "status = $value",
    ' OR '
);
// Returns: "status = 0 OR status = 1"
```

--------------------------------

### Generate HTML Select Options

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/options.md

Uses stringOptions to populate select elements with enum values.

```php
<select name="status">
    <?php echo TaskStatus::stringOptions(); ?>
</select>

<!-- Generates: -->
<select name="status">
    <option value="0">Incomplete</option>
    <option value="1">Completed</option>
    <option value="2">Canceled</option>
</select>
```

--------------------------------

### Perform Permission Checks with Comparable

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/comparable.md

Use the in() method to verify if a user role belongs to a specific set of authorized roles.

```php
use ArchTech\Enums\Comparable;

enum UserRole
{
    use Comparable;

    case ADMIN;
    case MODERATOR;
    case USER;
}

function canDeletePost(UserRole $role): bool
{
    return $role->in([UserRole::ADMIN, UserRole::MODERATOR]);
}

if (canDeletePost($currentUserRole)) {
    // Allow deletion
}
```

--------------------------------

### List Enum Case Names

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/names.md

Iterate over the array returned by names() to display all available enum options.

```php
foreach (TaskStatus::names() as $name) {
    echo "Task Status: $name\n";
}
```

--------------------------------

### UndefinedCaseError Constructor Definition

Source: https://github.com/archtechx/enums/blob/master/_autodocs/errors.md

The constructor signature for the UndefinedCaseError exception.

```php
public function __construct(string $enum, string $case)
```

--------------------------------

### Handling Errors with tryFrom() and tryFromName()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/from.md

Check for null return values when using non-throwing lookup methods.

```php
$status = TaskStatus::tryFromName($input);

if ($status === null) {
    // Handle: case not found
} else {
    // Use $status safely
}
```

--------------------------------

### Populate Dropdown Options

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/names.md

Transform the array of names into an associative array suitable for select elements.

```php
$options = [];
foreach (Role::names() as $name) {
    $options[$name] = $name;
}
```

--------------------------------

### Retrieving Enum Cases with tryFromMeta()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/metadata.md

Attempt to retrieve an enum case by metadata value, returning null if no match is found.

```php
use ArchTech
Enums
Metadata;
use ArchTech
Enums
Meta
Meta;
use Attribute;

#[Attribute]
class Color extends MetaProperty
{
}

#[Meta(Color::class)]
enum Status: int
{
    use Metadata;

    #[Color('red')]
    case INCOMPLETE = 0;

    #[Color('green')]
    case COMPLETE = 1;
}

$status = Status::tryFromMeta(Color::make('green'));
// Returns: Status::COMPLETE

$status = Status::tryFromMeta(Color::make('blue'));
// Returns: null
```

--------------------------------

### tryFromMeta()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/metadata.md

Attempts to retrieve an enum case by metadata value, returning null if no match is found.

```APIDOC
## static tryFromMeta()

### Description
Attempts to retrieve an enum case by metadata value, returning null if not found.

### Signature
`public static function tryFromMeta(MetaProperty $metaProperty): static|null`

### Parameters
- **$metaProperty** (MetaProperty) - Required - A MetaProperty instance with the value to match.

### Return Type
- **static|null** - The matching enum case, or null if not found.
```

--------------------------------

### Define the MetaProperty class structure

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/meta-property.md

The abstract class definition outlining the required methods and constructor for custom metadata attributes.

```php
abstract class MetaProperty
{
    final public function __construct(
        public mixed $value,
    )

    public static function defaultValue(): mixed

    public static function make(mixed $value): static

    protected function transform(mixed $value): mixed

    public static function method(): string
}
```

--------------------------------

### Retrieve Enum Case Names

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/names.md

Demonstrates using the Names trait in both backed and pure enums to retrieve an array of case names.

```php
use ArchTech\Enums\Names;

enum TaskStatus: int
{
    use Names;

    case INCOMPLETE = 0;
    case COMPLETED = 1;
    case CANCELED = 2;
}

TaskStatus::names(); // ['INCOMPLETE', 'COMPLETED', 'CANCELED']

enum Role
{
    use Names;

    case ADMINISTRATOR;
    case SUBSCRIBER;
    case GUEST;
}

Role::names(); // ['ADMINISTRATOR', 'SUBSCRIBER', 'GUEST']
```

--------------------------------

### stringOptions()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/options.md

Generates a string representation of enum options using a callback function or default HTML formatting.

```APIDOC
## stringOptions()

### Description
Generates a string representation of enum options. By default, it produces HTML <option> tags, but it can be customized using a callback function to format each option and a glue string to join them.

### Signature
`public static function stringOptions(?Closure $callback = null, string $glue = '\n'): string`

### Parameters
- **$callback** (Closure(string $name, mixed $value): string) - Optional - Callback to format each option. When null, uses default HTML <option> formatter.
- **$glue** (string) - Optional - String to join formatted options. Defaults to '\n'.

### Return Type
string - Formatted options joined by the glue string.

### Usage Example
```php
// Default HTML output
TaskStatus::stringOptions();

// Custom callback output
TaskStatus::stringOptions(
    fn ($name, $value) => "$name => $value",
    ', '
);
```
```

--------------------------------

### Declaring multiple properties variants

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/meta.md

Different ways to pass multiple properties to the Meta attribute.

```php
#[Meta(A::class, B::class, C::class)]
enum Status { /* ... */ }
```

```php
#[Meta([A::class, B::class, C::class])]
enum Status { /* ... */ }
```

```php
#[Meta([A::class, B::class], C::class)]
enum Status { /* ... */ }
```

--------------------------------

### E-Commerce Status Tracking with Metadata

Source: https://github.com/archtechx/enums/blob/master/_autodocs/trait-combinations.md

Implements an enum with custom metadata attributes and multiple traits for advanced functionality like label and color mapping.

```php
use ArchTech\Enums\InvokableCases;
use ArchTech\Enums\Options;
use ArchTech\Enums\From;
use ArchTech\Enums\Comparable;
use ArchTech\Enums\Metadata;
use ArchTech\Enums\Meta\Meta;

#[Attribute]
class StatusLabel extends MetaProperty {}

#[Attribute]
class StatusColor extends MetaProperty {}

#[Meta(StatusLabel::class, StatusColor::class)]
enum OrderStatus: string
{
    use InvokableCases, Options, From, Comparable, Metadata;

    #[StatusLabel('Pending Review')] #[StatusColor('orange')]
    case PENDING = 'pending';

    #[StatusLabel('Processing')] #[StatusColor('blue')]
    case PROCESSING = 'processing';

    #[StatusLabel('Shipped')] #[StatusColor('purple')]
    case SHIPPED = 'shipped';

    #[StatusLabel('Delivered')] #[StatusColor('green')]
    case DELIVERED = 'delivered';

    #[StatusLabel('Cancelled')] #[StatusColor('red')]
    case CANCELLED = 'cancelled';
}
```

--------------------------------

### Compare enum instances with isNot()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/comparable.md

Use the isNot() method to verify if an enum instance is different from another instance.

```php
use ArchTech\Enums\Comparable;

enum TaskStatus: int
{
    use Comparable;

    case INCOMPLETE = 0;
    case COMPLETED = 1;
}

$status = TaskStatus::INCOMPLETE;
$status->isNot(TaskStatus::INCOMPLETE); // false
$status->isNot(TaskStatus::COMPLETED);  // true

enum Role
{
    use Comparable;

    case ADMINISTRATOR;
    case SUBSCRIBER;
}

Role::ADMINISTRATOR->isNot(Role::ADMINISTRATOR); // false
Role::ADMINISTRATOR->isNot(Role::SUBSCRIBER);    // true
```

--------------------------------

### Retrieve values from backed enums

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/values.md

Demonstrates using the Values trait with integer and string backed enums to return an array of case values.

```php
use ArchTech\Enums\Values;

enum TaskStatus: int
{
    use Values;

    case INCOMPLETE = 0;
    case COMPLETED = 1;
    case CANCELED = 2;
}

TaskStatus::values(); // [0, 1, 2]

enum Priority: string
{
    use Values;

    case LOW = 'low';
    case MEDIUM = 'medium';
    case HIGH = 'high';
}

Priority::values(); // ['low', 'medium', 'high']
```

--------------------------------

### Retrieving Enum Cases with fromMeta()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/metadata.md

Retrieve the first enum case matching a specific metadata value, throwing a ValueError if no match is found.

```php
use ArchTech
Enums
Metadata;
use ArchTech
Enums
Meta
Meta;
use Attribute;

#[Attribute]
class Color extends MetaProperty
{
}

#[Meta(Color::class)]
enum Status: int
{
    use Metadata;

    #[Color('red')]
    case INCOMPLETE = 0;

    #[Color('green')]
    case COMPLETE = 1;
}

$status = Status::fromMeta(Color::make('green'));
echo $status->name; // COMPLETE

Status::fromMeta(Color::make('blue')); // Throws ValueError
```

--------------------------------

### fromMeta()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/metadata.md

Retrieves the first enum case that matches the specified metadata value.

```APIDOC
## static fromMeta()

### Description
Retrieves the first enum case that has the specified metadata value.

### Signature
`public static function fromMeta(MetaProperty $metaProperty): static`

### Parameters
- **$metaProperty** (MetaProperty) - Required - A MetaProperty instance with the value to match.

### Return Type
- **static** - The first enum case matching the metadata value.

### Throws
- **ValueError** - When no case matches the metadata value.
```

--------------------------------

### tryFromName(string $name)

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/from.md

Returns the enum case matching the provided name, or null if no match is found.

```APIDOC
## tryFromName(string $name)

### Description
Returns the enum case matching the provided name. If no case matches, returns null.

### Parameters
- **name** (string) - Required - The name of the enum case to retrieve.

### Returns
- **Enum|null** - The matching enum case instance or null.
```

--------------------------------

### Implement Metadata Trait Magic Methods

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/reflection.md

Internal implementation of the Metadata trait using reflection to resolve properties.

```php
// From Metadata.php
public function __call(string $property, array $arguments): mixed
{
    $metaProperties = Meta\Reflection::metaProperties($this);
    // ... lookup matching property ...
    return Meta\Reflection::metaValue($metaProperty, $this);
}
```

--------------------------------

### Handling Errors with from() and fromName()

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/from.md

Catch ValueError when using strict lookup methods.

```php
try {
    $status = TaskStatus::from('INVALID');
} catch (ValueError $e) {
    // Handle error: "INVALID" is not a valid name for enum TaskStatus
}
```

--------------------------------

### UndefinedCaseError Message Format

Source: https://github.com/archtechx/enums/blob/master/_autodocs/errors.md

The standard format for the error message generated by the exception.

```text
Undefined constant ArchTech\Enums\Tests\Fixtures\TaskStatus::INVALID
```

--------------------------------

### Passing an array to Meta

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/meta.md

MetaProperty classes can also be passed as a single array to the Meta attribute.

```php
use ArchTech
epEnums\Metadata;
use ArchTech
epEnums\Meta\Meta;

$properties = [Description::class, Color::class, Icon::class];

#[Meta($properties)]
enum Status: int
{
    use Metadata;
    // ...
}
```

--------------------------------

### Configure PHPStan for Enums

Source: https://github.com/archtechx/enums/blob/master/_autodocs/README.md

Include the provided extension in your phpstan.neon file to enable better type checking for InvokableCases.

```yaml
# phpstan.neon
includes:
  - ./vendor/archtechx/enums/extension.neon
```

--------------------------------

### Native PHP Enum Comparison

Source: https://github.com/archtechx/enums/blob/master/_autodocs/api-reference/comparable.md

Standard PHP identity checks and array searching for enum instances.

```php
// Identity comparison
if ($status === TaskStatus::COMPLETED) { }
if ($status !== TaskStatus::COMPLETED) { }

// Array search
if (in_array($status, [TaskStatus::COMPLETED, TaskStatus::CANCELED], strict: true)) { }
```
Tokens:
Raw