# Extension and action examples

<!-- Maintained by scripts/generate-package-readmes.php -->

Use the action functions with records and Data objects supplied by your application.
They pass each argument to the package operation and return its result.

These adapters show container registration. Use the owning package registry when
a contract requires contributor discovery.

Contract adapters wrap an existing implementation. Call their registration function
from your service provider with that implementation; tagged contracts keep their declared tag.
Resolve the backend by its concrete class before registration so the replacement contract
does not resolve itself. Static contract metadata uses one backend class per adapter.

## Contract `Capell\Shop\Contracts\ShopAgentToolCapability`

<!-- example: contract Capell\Shop\Contracts\ShopAgentToolCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopAgentToolCapabilityAdapter implements \Capell\Shop\Contracts\ShopAgentToolCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopAgentToolCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopAgentToolCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopAgentToolCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopAgentToolCapabilityAdapter(\Capell\Shop\Contracts\ShopAgentToolCapability $backend): void
{
    ShopAgentToolCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopAgentToolCapabilityAdapter::class, static fn (): ShopAgentToolCapabilityAdapter => new ShopAgentToolCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopAgentToolCapability::class, ShopAgentToolCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopCapability`

<!-- example: contract Capell\Shop\Contracts\ShopCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopCapabilityAdapter implements \Capell\Shop\Contracts\ShopCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopCapabilityAdapter(\Capell\Shop\Contracts\ShopCapability $backend): void
{
    ShopCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopCapabilityAdapter::class, static fn (): ShopCapabilityAdapter => new ShopCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopCapability::class, ShopCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopCapabilityManifestContribution`

<!-- example: contract Capell\Shop\Contracts\ShopCapabilityManifestContribution -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopCapabilityManifestContributionAdapter implements \Capell\Shop\Contracts\ShopCapabilityManifestContribution
{
    /** @var class-string<\Capell\Shop\Contracts\ShopCapabilityManifestContribution> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopCapabilityManifestContribution $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopCapabilityManifestContribution $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function capabilityContractVersion(): string
    {
        return self::$backendClass::capabilityContractVersion();
    }

    #[\Override]
    public static function capabilityImplementation(): string
    {
        return self::$backendClass::capabilityImplementation();
    }

    #[\Override]
    public static function capabilityKey(): string
    {
        return self::$backendClass::capabilityKey();
    }

    #[\Override]
    public static function capabilityPosition(): \Capell\Core\Support\Extensions\ExtensionPosition
    {
        return self::$backendClass::capabilityPosition();
    }

    #[\Override]
    public static function capabilityScope(): \Capell\Shop\Data\ShopCapabilityScopeData
    {
        return self::$backendClass::capabilityScope();
    }

    #[\Override]
    public static function capabilityType(): \Capell\Shop\Enums\ShopCapabilityType
    {
        return self::$backendClass::capabilityType();
    }

    #[\Override]
    public static function compatibleCapellApiVersion(): string
    {
        return self::$backendClass::compatibleCapellApiVersion();
    }
}

function registerShopCapabilityManifestContributionAdapter(\Capell\Shop\Contracts\ShopCapabilityManifestContribution $backend): void
{
    ShopCapabilityManifestContributionAdapter::configureMetadata($backend);
    app()->bind(ShopCapabilityManifestContributionAdapter::class, static fn (): ShopCapabilityManifestContributionAdapter => new ShopCapabilityManifestContributionAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopCapabilityManifestContribution::class, ShopCapabilityManifestContributionAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopCapabilityProvider`

<!-- example: contract Capell\Shop\Contracts\ShopCapabilityProvider -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopCapabilityProviderAdapter implements \Capell\Shop\Contracts\ShopCapabilityProvider
{
    public function __construct(private readonly \Capell\Shop\Contracts\ShopCapabilityProvider $backend) {}

    #[\Override]
    public function registerCapabilities(\Capell\Shop\Support\ShopCapabilityRegistry $registry): void
    {
        $this->backend->registerCapabilities($registry);
    }
}

function registerShopCapabilityProviderAdapter(\Capell\Shop\Contracts\ShopCapabilityProvider $backend): void
{
    app()->bind(ShopCapabilityProviderAdapter::class, static fn (): ShopCapabilityProviderAdapter => new ShopCapabilityProviderAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopCapabilityProvider::class, ShopCapabilityProviderAdapter::class);
    app()->tag([ShopCapabilityProviderAdapter::class], \Capell\Shop\Contracts\ShopCapabilityProvider::CAPABILITY_TAG);
}
```

## Contract `Capell\Shop\Contracts\ShopCatalogueCapability`

<!-- example: contract Capell\Shop\Contracts\ShopCatalogueCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopCatalogueCapabilityAdapter implements \Capell\Shop\Contracts\ShopCatalogueCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopCatalogueCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopCatalogueCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopCatalogueCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopCatalogueCapabilityAdapter(\Capell\Shop\Contracts\ShopCatalogueCapability $backend): void
{
    ShopCatalogueCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopCatalogueCapabilityAdapter::class, static fn (): ShopCatalogueCapabilityAdapter => new ShopCatalogueCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopCatalogueCapability::class, ShopCatalogueCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopExtension`

<!-- example: contract Capell\Shop\Contracts\ShopExtension -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopExtensionAdapter implements \Capell\Shop\Contracts\ShopExtension
{
    public function __construct(private readonly \Capell\Shop\Contracts\ShopExtension $backend) {}

    #[\Override]
    public function register(\Capell\Shop\Support\ShopExtensionRegistry $registry): void
    {
        $this->backend->register($registry);
    }
}

function registerShopExtensionAdapter(\Capell\Shop\Contracts\ShopExtension $backend): void
{
    app()->bind(ShopExtensionAdapter::class, static fn (): ShopExtensionAdapter => new ShopExtensionAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopExtension::class, ShopExtensionAdapter::class);
    app()->tag([ShopExtensionAdapter::class], \Capell\Shop\Contracts\ShopExtension::TAG);
}
```

## Contract `Capell\Shop\Contracts\ShopFulfilmentCapability`

<!-- example: contract Capell\Shop\Contracts\ShopFulfilmentCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopFulfilmentCapabilityAdapter implements \Capell\Shop\Contracts\ShopFulfilmentCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopFulfilmentCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopFulfilmentCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopFulfilmentCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopFulfilmentCapabilityAdapter(\Capell\Shop\Contracts\ShopFulfilmentCapability $backend): void
{
    ShopFulfilmentCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopFulfilmentCapabilityAdapter::class, static fn (): ShopFulfilmentCapabilityAdapter => new ShopFulfilmentCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopFulfilmentCapability::class, ShopFulfilmentCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopIdempotency`

<!-- example: contract Capell\Shop\Contracts\ShopIdempotency -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopIdempotencyAdapter implements \Capell\Shop\Contracts\ShopIdempotency
{
    public function __construct(private readonly \Capell\Shop\Contracts\ShopIdempotency $backend) {}

    #[\Override]
    public function claim(\Capell\Shop\Data\ShopIdempotencyRequestData $request): \Capell\Shop\Data\ShopIdempotencyLeaseData|\Capell\Shop\Data\ShopIdempotencyReplayData
    {
        return $this->backend->claim($request);
    }

    #[\Override]
    public function complete(\Capell\Shop\Data\ShopIdempotencyLeaseData $lease, \Capell\Shop\Data\ShopIdempotencyReplayData $result): void
    {
        $this->backend->complete($lease, $result);
    }
}

function registerShopIdempotencyAdapter(\Capell\Shop\Contracts\ShopIdempotency $backend): void
{
    app()->bind(ShopIdempotencyAdapter::class, static fn (): ShopIdempotencyAdapter => new ShopIdempotencyAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopIdempotency::class, ShopIdempotencyAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopInventoryCapability`

<!-- example: contract Capell\Shop\Contracts\ShopInventoryCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopInventoryCapabilityAdapter implements \Capell\Shop\Contracts\ShopInventoryCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopInventoryCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopInventoryCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopInventoryCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopInventoryCapabilityAdapter(\Capell\Shop\Contracts\ShopInventoryCapability $backend): void
{
    ShopInventoryCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopInventoryCapabilityAdapter::class, static fn (): ShopInventoryCapabilityAdapter => new ShopInventoryCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopInventoryCapability::class, ShopInventoryCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopLifecycleEvent`

<!-- example: contract Capell\Shop\Contracts\ShopLifecycleEvent -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopLifecycleEventAdapter implements \Capell\Shop\Contracts\ShopLifecycleEvent
{
    public function __construct(private readonly \Capell\Shop\Contracts\ShopLifecycleEvent $backend) {}

    #[\Override]
    public function toShopData(): \Capell\Shop\Data\ShopLifecycleEventData
    {
        return $this->backend->toShopData();
    }
}

function registerShopLifecycleEventAdapter(\Capell\Shop\Contracts\ShopLifecycleEvent $backend): void
{
    app()->bind(ShopLifecycleEventAdapter::class, static fn (): ShopLifecycleEventAdapter => new ShopLifecycleEventAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopLifecycleEvent::class, ShopLifecycleEventAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopMerchantOfRecordCapability`

<!-- example: contract Capell\Shop\Contracts\ShopMerchantOfRecordCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopMerchantOfRecordCapabilityAdapter implements \Capell\Shop\Contracts\ShopMerchantOfRecordCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopMerchantOfRecordCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopMerchantOfRecordCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopMerchantOfRecordCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopMerchantOfRecordCapabilityAdapter(\Capell\Shop\Contracts\ShopMerchantOfRecordCapability $backend): void
{
    ShopMerchantOfRecordCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopMerchantOfRecordCapabilityAdapter::class, static fn (): ShopMerchantOfRecordCapabilityAdapter => new ShopMerchantOfRecordCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopMerchantOfRecordCapability::class, ShopMerchantOfRecordCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopOrderLifecycleCapability`

<!-- example: contract Capell\Shop\Contracts\ShopOrderLifecycleCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopOrderLifecycleCapabilityAdapter implements \Capell\Shop\Contracts\ShopOrderLifecycleCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopOrderLifecycleCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopOrderLifecycleCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopOrderLifecycleCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopOrderLifecycleCapabilityAdapter(\Capell\Shop\Contracts\ShopOrderLifecycleCapability $backend): void
{
    ShopOrderLifecycleCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopOrderLifecycleCapabilityAdapter::class, static fn (): ShopOrderLifecycleCapabilityAdapter => new ShopOrderLifecycleCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopOrderLifecycleCapability::class, ShopOrderLifecycleCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopOutbox`

<!-- example: contract Capell\Shop\Contracts\ShopOutbox -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopOutboxAdapter implements \Capell\Shop\Contracts\ShopOutbox
{
    public function __construct(private readonly \Capell\Shop\Contracts\ShopOutbox $backend) {}

    #[\Override]
    public function enqueue(\Capell\Shop\Data\ShopOutboxMessageData $message): void
    {
        $this->backend->enqueue($message);
    }
}

function registerShopOutboxAdapter(\Capell\Shop\Contracts\ShopOutbox $backend): void
{
    app()->bind(ShopOutboxAdapter::class, static fn (): ShopOutboxAdapter => new ShopOutboxAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopOutbox::class, ShopOutboxAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopPaymentCapability`

<!-- example: contract Capell\Shop\Contracts\ShopPaymentCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopPaymentCapabilityAdapter implements \Capell\Shop\Contracts\ShopPaymentCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopPaymentCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopPaymentCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopPaymentCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopPaymentCapabilityAdapter(\Capell\Shop\Contracts\ShopPaymentCapability $backend): void
{
    ShopPaymentCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopPaymentCapabilityAdapter::class, static fn (): ShopPaymentCapabilityAdapter => new ShopPaymentCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopPaymentCapability::class, ShopPaymentCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopPaymentPurposeCapability`

<!-- example: contract Capell\Shop\Contracts\ShopPaymentPurposeCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopPaymentPurposeCapabilityAdapter implements \Capell\Shop\Contracts\ShopPaymentPurposeCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopPaymentPurposeCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopPaymentPurposeCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopPaymentPurposeCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopPaymentPurposeCapabilityAdapter(\Capell\Shop\Contracts\ShopPaymentPurposeCapability $backend): void
{
    ShopPaymentPurposeCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopPaymentPurposeCapabilityAdapter::class, static fn (): ShopPaymentPurposeCapabilityAdapter => new ShopPaymentPurposeCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopPaymentPurposeCapability::class, ShopPaymentPurposeCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopPipelineStage`

<!-- example: contract Capell\Shop\Contracts\ShopPipelineStage -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopPipelineStageAdapter implements \Capell\Shop\Contracts\ShopPipelineStage
{
    /** @var class-string<\Capell\Shop\Contracts\ShopPipelineStage> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopPipelineStage $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopPipelineStage $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }

    #[\Override]
    public static function dataClass(): string
    {
        return self::$backendClass::dataClass();
    }

    #[\Override]
    public static function failureSemantics(): \Capell\Shop\Enums\ShopPipelineFailure
    {
        return self::$backendClass::failureSemantics();
    }

    #[\Override]
    public function handle(\Capell\Shop\Data\ShopPipelineData $data): \Capell\Shop\Data\ShopPipelineData
    {
        return $this->backend->handle($data);
    }

    #[\Override]
    public static function sideEffects(): \Capell\Shop\Enums\ShopPipelineEffect
    {
        return self::$backendClass::sideEffects();
    }
}

function registerShopPipelineStageAdapter(\Capell\Shop\Contracts\ShopPipelineStage $backend): void
{
    ShopPipelineStageAdapter::configureMetadata($backend);
    app()->bind(ShopPipelineStageAdapter::class, static fn (): ShopPipelineStageAdapter => new ShopPipelineStageAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopPipelineStage::class, ShopPipelineStageAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopPricingCapability`

<!-- example: contract Capell\Shop\Contracts\ShopPricingCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopPricingCapabilityAdapter implements \Capell\Shop\Contracts\ShopPricingCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopPricingCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopPricingCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopPricingCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopPricingCapabilityAdapter(\Capell\Shop\Contracts\ShopPricingCapability $backend): void
{
    ShopPricingCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopPricingCapabilityAdapter::class, static fn (): ShopPricingCapabilityAdapter => new ShopPricingCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopPricingCapability::class, ShopPricingCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopPromotionCapability`

<!-- example: contract Capell\Shop\Contracts\ShopPromotionCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopPromotionCapabilityAdapter implements \Capell\Shop\Contracts\ShopPromotionCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopPromotionCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopPromotionCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopPromotionCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopPromotionCapabilityAdapter(\Capell\Shop\Contracts\ShopPromotionCapability $backend): void
{
    ShopPromotionCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopPromotionCapabilityAdapter::class, static fn (): ShopPromotionCapabilityAdapter => new ShopPromotionCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopPromotionCapability::class, ShopPromotionCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopRiskCapability`

<!-- example: contract Capell\Shop\Contracts\ShopRiskCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopRiskCapabilityAdapter implements \Capell\Shop\Contracts\ShopRiskCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopRiskCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopRiskCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopRiskCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopRiskCapabilityAdapter(\Capell\Shop\Contracts\ShopRiskCapability $backend): void
{
    ShopRiskCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopRiskCapabilityAdapter::class, static fn (): ShopRiskCapabilityAdapter => new ShopRiskCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopRiskCapability::class, ShopRiskCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopSearchCapability`

<!-- example: contract Capell\Shop\Contracts\ShopSearchCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopSearchCapabilityAdapter implements \Capell\Shop\Contracts\ShopSearchCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopSearchCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopSearchCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopSearchCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopSearchCapabilityAdapter(\Capell\Shop\Contracts\ShopSearchCapability $backend): void
{
    ShopSearchCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopSearchCapabilityAdapter::class, static fn (): ShopSearchCapabilityAdapter => new ShopSearchCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopSearchCapability::class, ShopSearchCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopShippingCapability`

<!-- example: contract Capell\Shop\Contracts\ShopShippingCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopShippingCapabilityAdapter implements \Capell\Shop\Contracts\ShopShippingCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopShippingCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopShippingCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopShippingCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopShippingCapabilityAdapter(\Capell\Shop\Contracts\ShopShippingCapability $backend): void
{
    ShopShippingCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopShippingCapabilityAdapter::class, static fn (): ShopShippingCapabilityAdapter => new ShopShippingCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopShippingCapability::class, ShopShippingCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopSurfaceCapability`

<!-- example: contract Capell\Shop\Contracts\ShopSurfaceCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopSurfaceCapabilityAdapter implements \Capell\Shop\Contracts\ShopSurfaceCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopSurfaceCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopSurfaceCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopSurfaceCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopSurfaceCapabilityAdapter(\Capell\Shop\Contracts\ShopSurfaceCapability $backend): void
{
    ShopSurfaceCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopSurfaceCapabilityAdapter::class, static fn (): ShopSurfaceCapabilityAdapter => new ShopSurfaceCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopSurfaceCapability::class, ShopSurfaceCapabilityAdapter::class);
}
```

## Contract `Capell\Shop\Contracts\ShopTaxCapability`

<!-- example: contract Capell\Shop\Contracts\ShopTaxCapability -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

final class ShopTaxCapabilityAdapter implements \Capell\Shop\Contracts\ShopTaxCapability
{
    /** @var class-string<\Capell\Shop\Contracts\ShopTaxCapability> */
    private static string $backendClass;

    public function __construct(private readonly \Capell\Shop\Contracts\ShopTaxCapability $backend) {}

    public static function configureMetadata(\Capell\Shop\Contracts\ShopTaxCapability $backend): void
    {
        $class = $backend::class;
        if (isset(self::$backendClass) && self::$backendClass !== $class) {
            throw new \LogicException('Use a separate adapter for each metadata implementation.');
        }
        self::$backendClass = $class;
    }

    #[\Override]
    public static function contractVersion(): string
    {
        return self::$backendClass::contractVersion();
    }
}

function registerShopTaxCapabilityAdapter(\Capell\Shop\Contracts\ShopTaxCapability $backend): void
{
    ShopTaxCapabilityAdapter::configureMetadata($backend);
    app()->bind(ShopTaxCapabilityAdapter::class, static fn (): ShopTaxCapabilityAdapter => new ShopTaxCapabilityAdapter($backend));
    app()->bind(\Capell\Shop\Contracts\ShopTaxCapability::class, ShopTaxCapabilityAdapter::class);
}
```

## Action `install`

<!-- example: action install -->

```php
<?php
declare(strict_types=1);

namespace App\CapellExamples\Shop;

function runInstall(\Capell\Core\Data\PackageData $package, array $arguments = [], ?\Capell\Core\Contracts\ProgressReporter $reporter = null): void
{
    \Capell\Shop\Actions\InstallShopPackageAction::run($package, $arguments, $reporter);
}
```