Subscriptionify

https://github.com/revoltify/subscriptionify
Admin
Subscriptionify is a feature-based subscription management package for Laravel that provides...
Tokens:8,321
Snippets:84
Trust Score:7.3
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Subscriptionify via Composer

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Use this command to add the package to your Laravel project.

```bash
composer require revoltify/subscriptionify
```

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

### Listen for Feature Consumption Events

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Example of an event listener class to handle the FeatureConsumed event.

```php
// Example: Listen for feature consumption
use Revoltify\Subscriptionify\Events\FeatureConsumed;

class TrackApiUsage
{
    public function handle(FeatureConsumed $event): void
    {
        // $event->subscribable
        // $event->feature
        // $event->units
        // $event->remaining
        // $event->cost
        // $event->usedOverage
    }
}
```

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

### Publish and Run Migrations

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Publish the configuration and migration files, then run the migrations to set up the necessary database tables.

```bash
php artisan vendor:publish --tag=subscriptionify-config
php artisan vendor:publish --tag=subscriptionify-migrations
php artisan migrate
```

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

### Define Subscription Plans

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Create various plan configurations including free, trial-enabled, and different billing intervals.

```php
// Free plan — never expires
Plan::create(['name' => 'Free', 'slug' => 'free', 'is_free' => true]);

// Monthly plan with trial
Plan::create([
    'name'             => 'Pro',
    'slug'             => 'pro',
    'billing_period'   => 1,
    'billing_interval' => Interval::Month,
    'trial_days'       => 14,
    'grace_days'       => 3,
]);

// Quarterly plan
Plan::create([
    'name'             => 'Business',
    'slug'             => 'business',
    'billing_period'   => 3,
    'billing_interval' => Interval::Month,
]);

// Yearly plan
Plan::create([
    'name'             => 'Enterprise',
    'slug'             => 'enterprise',
    'billing_period'   => 1,
    'billing_interval' => Interval::Year,
    'grace_days'       => 7,
]);
```

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

### Create a subscription

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Initiate a subscription for a team using a plan, with an optional custom end date.

```php
$team->subscribe($plan);

// With custom end date
$team->subscribe($plan, endsAt: now()->addMonths(6));
```

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

### Manage Plans and Subscriptions

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Create plans, attach features with usage limits, and manage user subscriptions.

```php
use Revoltify\Subscriptionify\Models\Plan;
use Revoltify\Subscriptionify\Models\Feature;
use Revoltify\Subscriptionify\Enums\FeatureType;
use Revoltify\Subscriptionify\Enums\Interval;

// Create a plan
$plan = Plan::create([
    'name'             => 'Pro',
    'slug'             => 'pro',
    'billing_period'   => 1,
    'billing_interval' => Interval::Month,
    'trial_days'       => 14,
]);

// Create features and attach to plan
$apiCalls = Feature::create(['name' => 'API Calls', 'slug' => 'api-calls', 'type' => FeatureType::Consumable]);

$plan->features()->attach($apiCalls, [
    'value'      => 10_000,
    'unit_price' => '0.00100000',
]);

// Subscribe
$team->subscribe($plan);

// Use features
$team->consume('api-calls', 100);
$team->remainingUsage('api-calls');   // 9900
$team->remainingOverage('api-calls'); // extra units affordable from balance
```

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

### Publish Configuration File

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Use the artisan command to publish the package configuration file to your project.

```bash
php artisan vendor:publish --tag=subscriptionify-config
```

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

### $team->subscriptionInfo()

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Retrieves a complete subscription snapshot for building UI components.

```APIDOC
## $team->subscriptionInfo()

### Description
Returns a comprehensive snapshot of the current subscription, including plan details, status, billing intervals, and associated features.

### Returns
- **SubscriptionInfo** (object) - An object containing subscription metadata, status, and a collection of FeatureInfo objects.
```

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

### Plan Configuration Methods

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Methods available on Plan model instances to retrieve configuration details.

```APIDOC
## Plan Instance Methods

- `$plan->getName()`: Returns the plan display name.
- `$plan->getSlug()`: Returns the unique plan identifier.
- `$plan->getDescription()`: Returns the plan description.
- `$plan->isFree()`: Returns true if the plan is free.
- `$plan->isActive()`: Returns true if the plan is active.
- `$plan->getTrialDays()`: Returns the number of trial days.
- `$plan->hasTrialDays()`: Returns true if the plan has a trial period.
- `$plan->getBillingPeriod()`: Returns the billing period integer.
- `$plan->getBillingInterval()`: Returns the billing interval enum.
- `$plan->getGraceDays()`: Returns the number of grace days.
- `$plan->hasGraceDays()`: Returns true if the plan has grace days.
- `$plan->getSortOrder()`: Returns the sort order integer.
- `$plan->calculateEndsAt(Carbon $date)`: Calculates the end date for the subscription.
```

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

### Access Plan Methods

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Retrieve plan configuration details and calculate expiration dates using built-in methods.

```php
$plan->getName();              // 'Pro'
$plan->getSlug();              // 'pro'
$plan->getDescription();       // 'Professional plan'
$plan->isFree();               // false
$plan->isActive();             // true
$plan->getTrialDays();         // 14
$plan->hasTrialDays();         // true
$plan->getBillingPeriod();     // 1
$plan->getBillingInterval();   // Interval::Month
$plan->getGraceDays();         // 3
$plan->hasGraceDays();         // true
$plan->getSortOrder();         // 0
$plan->calculateEndsAt(now()); // Carbon (null for free plans)
```

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

### Manage subscription lifecycle

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Perform administrative actions on a subscription including plan changes, renewals, and cancellations.

```php
$subscription = $team->subscription();

// Change plans
$subscription->changePlan($newPlan);
$subscription->changePlan($newPlan, endsAt: now()->addYear());
$subscription->changePlan($newPlan, resetUsages: true); // resets consumable usages

// Renew
$subscription->renew();
$subscription->renew(endsAt: now()->addYear());

// Cancel
$subscription->cancel();       // at end of billing period (grace period applies)
$subscription->cancelNow();    // immediately

// Resume (only during grace period)
$subscription->resume();

// Lifecycle
$subscription->expire();
$subscription->markPastDue();
```

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

### Check subscription status on subscription instance

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Verify specific details and states of an individual subscription instance.

```php
$subscription = $team->subscription();

$subscription->active();              // active or trialing
$subscription->onTrial();             // in trial period
$subscription->recurring();           // active, not trialing
$subscription->canceled();            // has been cancelled
$subscription->onGracePeriod();       // cancelled but still within grace period
$subscription->ended();               // cancelled and past grace period
$subscription->pastDue();             // marked as past due
$subscription->expired();             // status is Expired, or Active with past ends_at
$subscription->valid();               // active || trialing || on grace period
$subscription->hasPlan('pro');        // on a specific plan by slug
$subscription->daysRemaining();       // days until ends_at
$subscription->trialDaysRemaining();  // days remaining in trial
```

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

### Run Subscription Expiration Command

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Executes the artisan command to transition overdue subscriptions to an expired status.

```bash
php artisan subscriptionify:expire-overdue
```

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

### Configure Subscriptionify Settings

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Customize model classes, database table names, and middleware aliases in the configuration file.

```php
// config/subscriptionify.php

return [
    // Override with your own models (must extend base or implement contracts)
    'models' => [
        'plan'         => Plan::class,
        'feature'      => Feature::class,
        'subscription' => Subscription::class,
    ],

    // Rename tables if they conflict (e.g. with Cashier)
    'tables' => [
        'plans'                => 'plans',
        'features'             => 'features',
        'feature_plan'         => 'feature_plan',
        'subscriptions'        => 'subscriptions',
        'feature_usages'       => 'feature_usages',
        'feature_subscribable' => 'feature_subscribable',
    ],

    // Rename middleware aliases if they conflict
    'middleware' => [
        'subscribed' => 'subscribed',
        'plan'       => 'plan',
        'feature'    => 'feature',
    ],
];
```

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

### Retrieve Subscription Information

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Provides a complete snapshot of the subscription status for building user interfaces.

```php
$info = $team->subscriptionInfo();

$info->planName;           // 'Pro'
$info->planSlug;           // 'pro'
$info->isFree;             // false
$info->status;             // SubscriptionStatus::Active
$info->billingInterval;    // Interval::Month
$info->billingPeriod;      // 1
$info->startsAt;           // '2026-04-01 00:00:00'
$info->endsAt;             // '2026-05-01 00:00:00'
$info->trialEndsAt;        // null
$info->onTrial;            // false
$info->onGracePeriod;      // false
$info->features;           // Collection<int, FeatureInfo>
$info->isActive();         // true
```

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

### Git Branching and Quality Assurance Commands

Source: https://github.com/revoltify/subscriptionify/blob/1.x/CONTRIBUTING.md

Commands for creating a feature branch and executing the project's test, style, static analysis, and modernization tools.

```bash
git checkout -b feature/my-feature
```

```bash
# Tests
./vendor/bin/pest

# Code style
./vendor/bin/pint

# Static analysis
./vendor/bin/phpstan analyse

# Code modernization
./vendor/bin/rector --dry-run
```

```bash
git commit -m 'Add my feature'
```

```bash
git push origin feature/my-feature
```

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

### Run Pest tests

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Executes the Pest test runner from the vendor directory.

```bash
./vendor/bin/pest
```

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

### Retrieve All Features

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Fetches a collection of all feature information objects for the team.

```php
$features = $team->allFeatures(); // Collection<int, FeatureInfo>
```

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

### Registering Subscription Middleware

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Apply middleware to route groups to restrict access based on subscription status, plan, or specific features.

```php
Route::middleware('subscribed')->group(function () {
    // Only accessible with an active subscription
});

Route::middleware('plan:pro')->group(function () {
    // Only accessible on the Pro plan
});

Route::middleware('feature:api-calls')->group(function () {
    // Only accessible if the subscribable has the api-calls feature
});
```

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

### Attach Features to Plans

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Associate features with plans using a pivot table, defining allocation values like quota limits and reset intervals.

```php
$plan->features()->attach($feature, [
    'value'          => 10_000,        // quota limit (0 = unlimited)
    'unit_price'     => '0.00100000',  // overage/metered price per unit
    'reset_period'   => 1,             // reset cycle length
    'reset_interval' => 'month',       // day, week, month, or year
]);
```

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

### Subscription Lifecycle Operations

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Methods to manage the lifecycle of an existing subscription instance.

```APIDOC
## Subscription Lifecycle Methods

### Methods
- `$subscription->changePlan($newPlan, $endsAt = null, $resetUsages = false)`: Updates the subscription to a new plan.
- `$subscription->renew()`: Renews the subscription.
- `$subscription->cancel()`: Cancels the subscription at the end of the billing period.
- `$subscription->cancelNow()`: Cancels the subscription immediately.
- `$subscription->resume()`: Resumes a cancelled subscription during the grace period.
```

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

### Feature Usage Methods

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Methods available on the subscribable model to check access, consume units, and monitor usage quotas.

```APIDOC
## hasFeature(string $feature)

### Description
Checks if the subscribable model has access to a specific feature.

### Parameters
- **$feature** (string) - Required - The feature identifier.

## canConsume(string $feature, int $units)

### Description
Checks if the specified number of units can be consumed for a feature.

### Parameters
- **$feature** (string) - Required - The feature identifier.
- **$units** (int) - Required - The number of units to check.

## consume(string $feature, int $units)

### Description
Consumes units for a feature. Throws a FeatureException if the quota is exceeded.

### Parameters
- **$feature** (string) - Required - The feature identifier.
- **$units** (int) - Required - The number of units to consume.

## tryConsume(string $feature, int $units)

### Description
Attempts to consume units for a feature. Returns false instead of throwing an exception if the quota is exceeded.

### Parameters
- **$feature** (string) - Required - The feature identifier.
- **$units** (int) - Required - The number of units to consume.

## remainingUsage(string $feature)

### Description
Returns the remaining quota for a specific feature.

### Parameters
- **$feature** (string) - Required - The feature identifier.

## remainingOverage(string $feature)

### Description
Returns the remaining overage capacity for a feature based on balance and unit price.

### Parameters
- **$feature** (string) - Required - The feature identifier.

## isUnlimitedUsage(string $feature)

### Description
Checks if the feature has an unlimited quota.

### Parameters
- **$feature** (string) - Required - The feature identifier.

## release(string $feature, int $units)

### Description
Releases units for a Limit-type feature to free up slots.

### Parameters
- **$feature** (string) - Required - The feature identifier.
- **$units** (int) - Required - The number of units to release.
```

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

### Implement Custom Subscription Resolution

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Override the resolveSubscription method in your model to define custom logic for selecting the active subscription.

```php
use Revoltify\\/Subscriptionify\\Enums\\SubscriptionStatus;
use Revoltify\\/Subscriptionify\\Models\\Contracts\\HasSubscription;

class Team extends Model implements Subscribable
{
    use InteractsWithSubscriptions;

    protected function resolveSubscription(): ?HasSubscription
    {
        return $this->subscriptions()
            ->whereIn('status', [
                SubscriptionStatus::Active,
                SubscriptionStatus::Trialing,
                SubscriptionStatus::PastDue, // also include past-due
            ])
            ->with('plan')
            ->latest()
            ->first();
    }
}
```

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

### Check subscription status on subscribable

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Verify the subscription status directly from the subscribable model instance.

```php
$team->subscribed();               // has active/trialing subscription
$team->onPlan($plan);             // on a specific plan
$team->onTrial();                 // currently in trial
$team->onFreePlan();              // on a free plan
$team->canChangePlan($otherPlan); // not already on that plan
```

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

### Configure Subscribable Model

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Implement the Subscribable contract and use the InteractsWithSubscriptions trait in your Eloquent model.

```php
use Revoltify\Subscriptionify\Concerns\InteractsWithSubscriptions;
use Revoltify\Subscriptionify\Contracts\Subscribable;

class Team extends Model implements Subscribable
{
    use InteractsWithSubscriptions;
}
```

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

### Create Subscription Features

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Define new features using the Feature model and specify their type using the FeatureType enum.

```php
use Revoltify\Subscriptionify\Models\Feature;
use Revoltify\Subscriptionify\Enums\FeatureType;

Feature::create(['name' => 'Custom Branding', 'slug' => 'branding',  'type' => FeatureType::Toggle]);
Feature::create(['name' => 'API Calls',       'slug' => 'api-calls', 'type' => FeatureType::Consumable]);
Feature::create(['name' => 'Projects',        'slug' => 'projects',  'type' => FeatureType::Limit]);
Feature::create(['name' => 'Compute Hours',   'slug' => 'compute',   'type' => FeatureType::Metered]);
```

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

### Handle Subscriptionify Exceptions

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Catch specific exceptions when consuming features or checking subscription status.

```php
use Revoltify\Subscriptionify\Exceptions\SubscriptionException;
use Revoltify\Subscriptionify\Exceptions\FeatureException;
use Revoltify\Subscriptionify\Exceptions\InsufficientFundsException;

try {
    $team->consume('api-calls', 100);
} catch (FeatureException $e) {
    // Quota exceeded
} catch (InsufficientFundsException $e) {
    // Insufficient balance for overage
}
```

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

### Implement HasFunds for Metered Billing

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Implement the HasFunds contract on your model to enable balance-based billing and overage deductions.

```php
use Revoltify\Subscriptionify\Contracts\HasFunds;

class Team extends Model implements Subscribable, HasFunds
{
    use InteractsWithSubscriptions;

    /** @return numeric-string */
    public function getBalance(): string
    {
        return $this->balance;
    }

    public function hasSufficientFunds(string $amount): bool
    {
        return bccomp($this->balance, $amount, 8) >= 0;
    }

    public function deductFunds(string $amount, string $description): void
    {
        /** @var numeric-string $newBalance */
        $newBalance = bcsub($this->balance, $amount, 8);

        $this->update(['balance' => $newBalance]);
    }
}
```

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

### Retrieve Feature Information

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Accesses a rich snapshot of a specific feature's current state for a subscribable.

```php
$feature = $team->featureInfo('api-calls');

$feature->name;              // 'API Calls'
$feature->slug;              // 'api-calls'
$feature->type;              // FeatureType::Consumable
$feature->limit;             // 10000
$feature->used;              // 3500
$feature->remaining;         // 6500
$feature->percentage;        // '35.00%'
$feature->unlimited;         // false
$feature->applicable;        // true (false for toggle features)
$feature->validUntil;        // '2026-05-01 00:00:00'
$feature->overageAvailable;  // true (HasFunds + unit price configured)
$feature->unitPrice;         // '0.00100000'
$feature->resetPeriod;       // 1
$feature->resetInterval;     // Interval::Month
```

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

### $team->allFeatures()

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Retrieves a collection of all features associated with the subscribable.

```APIDOC
## $team->allFeatures()

### Description
Returns a collection of all features available to the team, each represented as a FeatureInfo object.

### Returns
- **Collection<int, FeatureInfo>** - A collection containing the state of all features.
```

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

### Manage Subscribable Model Features

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Perform feature checks and consumption operations directly on the subscribable model instance.

```php
// Check access (does the subscribable have this feature?)
$team->hasFeature('api-calls');

// Check if specific units can be consumed
$team->canConsume('api-calls', 100);

// Consume units (throws FeatureException if quota exceeded)
$team->consume('api-calls', 100);

// Try to consume (returns false instead of throwing)
$team->tryConsume('api-calls', 100);

// Check remaining plan quota
$team->remainingUsage('api-calls');

// Check remaining overage capacity (balance / unit_price)
// Requires HasFunds + unit_price configured, returns '0' otherwise
$team->remainingOverage('api-calls');

// Check if feature has unlimited quota
$team->isUnlimitedUsage('api-calls'); // true if unlimited

// Release units (Limit type only — frees up slots)
$team->release('projects', 1);
```

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

### Subscription Status Checks

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Methods to verify the subscription status of a model or a specific subscription instance.

```APIDOC
## Status Check Methods

### Description
Methods to check the current state of a subscription or model's subscription status.

### Model Methods
- `$team->subscribed()`: Returns true if the model has an active or trialing subscription.
- `$team->onPlan($plan)`: Returns true if the model is on the specified plan.
- `$team->onTrial()`: Returns true if the model is currently in a trial period.
- `$team->onFreePlan()`: Returns true if the model is on a free plan.

### Subscription Instance Methods
- `$subscription->active()`: Returns true if active or trialing.
- `$subscription->canceled()`: Returns true if the subscription has been cancelled.
- `$subscription->pastDue()`: Returns true if the subscription is marked as past due.
- `$subscription->valid()`: Returns true if active, trialing, or on grace period.
```

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

### Subscription Management Methods

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Methods available on the subscribable model to manage subscriptions.

```APIDOC
## $team->subscribe($plan, $endsAt = null)

### Description
Creates a new subscription for the model. If the plan has trial days, it starts in a 'Trialing' status.

### Parameters
- **$plan** (object) - Required - The plan instance to subscribe to.
- **$endsAt** (DateTime) - Optional - Custom end date for the subscription.
```

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

### Apply Direct Feature Grants

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Grant features directly to a subscribable model, which adds to any existing plan quotas.

```php
// Grant with quota
$team->grantFeature('api-calls', value: 50_000);

// Grant with custom unit price for overage
$team->grantFeature('api-calls', value: 50_000, unitPrice: '0.00050000');

// Grant with auto-reset
$team->grantFeature('reports', value: 100, resetPeriod: 1, resetInterval: Interval::Month);

// Grant unlimited (value: 0)
$team->grantFeature('api-calls', value: 0);

// Revoke direct grant (plan quota still applies)
$team->revokeFeature('api-calls');
```

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

### Access Feature Metadata

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Retrieve information about a feature instance using its getter methods and type-checking helpers.

```php
$feature->getName();           // 'API Calls'
$feature->getSlug();           // 'api-calls'
$feature->getDescription();    // 'Monthly API call quota'
$feature->getType();           // FeatureType::Consumable
$feature->hasQuota();          // true (consumable & limit)
$feature->isToggle();          // false
$feature->isConsumable();      // true
$feature->isLimit();           // false
$feature->isMetered();         // false
```

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

### Required PHP File Header

Source: https://github.com/revoltify/subscriptionify/blob/1.x/CONTRIBUTING.md

Mandatory declaration for all PHP files to ensure strict typing.

```php
declare(strict_types=1)
```

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

### Extend Base Models

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Create a custom model class by extending the base Subscriptionify model to add custom columns or relationships.

```php
use Revoltify\\/Subscriptionify\\Models\\Plan as BasePlan;

class Plan extends BasePlan
{
    // Add your own columns, relationships, or methods
}
```

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

### $team->featureInfo(string $slug)

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Retrieves a rich snapshot of a specific feature's current state for a subscribable.

```APIDOC
## $team->featureInfo(string $slug)

### Description
Retrieves a rich snapshot of a feature's current state, including limits, usage, and reset intervals.

### Parameters
- **slug** (string) - Required - The unique identifier for the feature.

### Returns
- **FeatureInfo** (object) - An object containing feature details such as name, limit, used, remaining, and reset configuration.
```

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

### Blade Directives

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Blade directives for conditional rendering based on subscription state.

```APIDOC
## Blade Directives

### Description
Directives to conditionally display content in Blade templates.

### Available Directives
- `@subscribed` / `@endsubscribed`: Content for active subscriptions.
- `@plan('slug')` / `@endplan`: Content for specific plans.
- `@feature('slug')` / `@endfeature`: Content for specific features.
- `@onTrial` / `@endonTrial`: Content for trial periods.
- `@onFreePlan` / `@endonFreePlan`: Content for free plans.
- `@onGracePeriod` / `@endonGracePeriod`: Content for grace periods.
```

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

### Applying Query Scopes

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Filter models using query scopes provided by the InteractsWithSubscriptions trait.

```php
// All teams with active/trialing subscriptions
Team::whereSubscribed()->get();

// All teams on a specific plan
Team::whereOnPlan($proPlan)->get();

// All teams currently in trial
Team::whereOnTrial()->get();

// All teams with expired subscriptions
Team::whereExpired()->get();
```

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

### Using Blade Directives

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Use these directives in Blade templates to conditionally display content based on subscription state or plan.

```blade
@subscribed
    {{-- Active subscription content --}}
@endsubscribed

@plan('pro')
    {{-- Pro plan only content --}}
@endplan

@feature('custom-branding')
    {{-- Custom branding enabled --}}
@endfeature

@onTrial
    {{-- Trial period notice --}}
@endonTrial

@onFreePlan
    {{-- Upgrade prompt --}}
@endonFreePlan

@onGracePeriod
    {{-- Grace period warning --}}
@endonGracePeriod
```

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

### Register Custom Models

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Register the custom model class in the subscriptionify configuration file.

```php
// config/subscriptionify.php
'models' => [
    'plan' => \\App\\Models\\Plan::class,
],
```

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

### Access Consumption Results

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Contains data returned internally after consuming units.

```php
$result->remaining;   // 6500
$result->cost;        // '0.00000000' or '0.50000000' (if overage)
$result->usedOverage; // false or true
```

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

### Subscription Management Methods

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Methods available on models using the InteractsWithSubscriptions trait to manage subscriptions and feature usage.

```APIDOC
## Method: subscribe

### Description
Subscribes the model to a specific plan.

### Signature
`$model->subscribe(Plan $plan)`

## Method: consume

### Description
Consumes a specified amount of a feature.

### Signature
`$model->consume(string $slug, int $amount)`

## Method: remainingUsage

### Description
Returns the remaining units available for a specific feature.

### Signature
`$model->remainingUsage(string $slug)`

## Method: remainingOverage

### Description
Returns extra units affordable from the balance for a specific feature.

### Signature
`$model->remainingOverage(string $slug)`
```

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

### Route Middleware

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Middleware used to restrict route access based on subscription status, plan, or specific features.

```APIDOC
## Route Middleware

### Description
Middleware that can be applied to routes to enforce subscription requirements. These throw 403 responses on failure.

### Usage
- `subscribed`: Requires active subscription. Usage: `Route::middleware('subscribed')`
- `plan:{slug}`: Requires specific plan. Usage: `Route::middleware('plan:pro')`
- `feature:{slug}`: Requires specific feature. Usage: `Route::middleware('feature:api-calls')`
```

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

### Check Remaining Overage Capacity

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Use the remainingOverage method to determine how many additional units a subscribable can afford based on their current balance.

```php
// Plan quota: 10,000 | Unit price: $0.001 | Balance: $50.00
$team->remainingUsage('api-calls');   // '10000' — plan quota remaining
$team->remainingOverage('api-calls'); // '50000' — extra units affordable (50 / 0.001)
```

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

### Schedule Subscription Expiration

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Registers the expiration command in the Laravel console schedule to run hourly.

```php
use Illuminate\Support\Facades\Schedule;

Schedule::command('subscriptionify:expire-overdue')->hourly();
```

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

### Query Scopes

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Eloquent query scopes for filtering models based on subscription status.

```APIDOC
## Query Scopes

### Description
Scopes available on models using the `InteractsWithSubscriptions` trait.

### Available Scopes
- `whereSubscribed()`: Filter by active or trialing subscriptions.
- `whereOnPlan($plan)`: Filter by specific plan.
- `whereOnTrial()`: Filter by trial status.
- `whereExpired()`: Filter by expired subscriptions.
```

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

### Override Subscribable Resolver

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Change the default subscribable entity by registering a custom resolver in the AppServiceProvider.

```php
use Revoltify\\/Subscriptionify\\Subscriptionify;

public function boot(): void
{
    Subscriptionify::resolveSubscribableUsing(fn () => Team::current());
}
```

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

### Access Pivot Allocation Data

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Retrieve allocation details from the pivot model using the HasFeaturePivot contract methods.

```php
$feature = $plan->features()->first();

$feature->pivot->getValue();        // 10000
$feature->pivot->getUnitPrice();    // '0.00100000'
$feature->pivot->getResetPeriod();  // 1
$feature->pivot->getResetInterval();// Interval::Month
$feature->pivot->getResetDate();    // Carbon (next reset date)
```

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

### Direct Feature Grants

Source: https://github.com/revoltify/subscriptionify/blob/1.x/README.md

Methods to grant or revoke features directly to a subscribable model, independent of their subscription plan.

```APIDOC
## grantFeature(string $feature, int $value, ?string $unitPrice, ?int $resetPeriod, ?Interval $resetInterval)

### Description
Grants a feature directly to a subscribable model. Grants are additive to existing plan quotas.

### Parameters
- **$feature** (string) - Required - The feature identifier.
- **$value** (int) - Required - The quota value (0 for unlimited).
- **$unitPrice** (string) - Optional - Custom unit price for overage.
- **$resetPeriod** (int) - Optional - The reset period duration.
- **$resetInterval** (Interval) - Optional - The reset interval (e.g., Interval::Month).

## revokeFeature(string $feature)

### Description
Revokes a direct feature grant from the subscribable model.

### Parameters
- **$feature** (string) - Required - The feature identifier to revoke.
```
Tokens:
Raw