<?php //e81d81bbe8ff456ee8ea189d73867e7e
/** @noinspection all */

namespace App\Events {

    use App\Models\Message;
    use Illuminate\Broadcasting\PendingBroadcast;
    
    /**
     * @method static void dispatch(Message $message)
     * @method static PendingBroadcast broadcast(Message $message)
     */
    class MessageSent {}
}

namespace Illuminate\Broadcasting {
    
    /**
     * @method static void dispatch(array|Channel|string $channels)
     * @method static PendingBroadcast broadcast(array|Channel|string $channels)
     */
    class AnonymousEvent {}
}

namespace Illuminate\Bus {

    use Illuminate\Foundation\Bus\PendingDispatch;
    use Illuminate\Support\Fluent;
    
    /**
     * @method static PendingDispatch dispatch(PendingBatch $batch)
     * @method static PendingDispatch|Fluent dispatchIf(boolean $bool, PendingBatch $batch)
     * @method static PendingDispatch|Fluent dispatchUnless(boolean $bool, PendingBatch $batch)
     * @method static mixed dispatchSync(PendingBatch $batch)
     * @method static void dispatchAfterResponse(PendingBatch $batch)
     */
    class ChainedBatch {}
}

namespace Illuminate\Foundation\Console {

    use Illuminate\Foundation\Bus\PendingDispatch;
    use Illuminate\Support\Fluent;
    
    /**
     * @method static PendingDispatch dispatch(array $data)
     * @method static PendingDispatch|Fluent dispatchIf(boolean $bool, array $data)
     * @method static PendingDispatch|Fluent dispatchUnless(boolean $bool, array $data)
     * @method static mixed dispatchSync(array $data)
     * @method static void dispatchAfterResponse(array $data)
     */
    class QueuedCommand {}
}

namespace Illuminate\Foundation\Events {

    use Illuminate\Broadcasting\PendingBroadcast;
    
    /**
     * @method static void dispatch(array $stubs)
     * @method static PendingBroadcast broadcast(array $stubs)
     */
    class PublishingStubs {}
}

namespace Illuminate\Queue {

    use Illuminate\Foundation\Bus\PendingDispatch;
    use Illuminate\Support\Fluent;
    use Laravel\SerializableClosure\SerializableClosure;
    
    /**
     * @method static PendingDispatch dispatch(SerializableClosure $closure)
     * @method static PendingDispatch|Fluent dispatchIf(boolean $bool, SerializableClosure $closure)
     * @method static PendingDispatch|Fluent dispatchUnless(boolean $bool, SerializableClosure $closure)
     * @method static mixed dispatchSync(SerializableClosure $closure)
     * @method static void dispatchAfterResponse(SerializableClosure $closure)
     */
    class CallQueuedClosure {}
}

namespace Laravel\Reverb\Events {

    use Illuminate\Broadcasting\PendingBroadcast;
    use Laravel\Reverb\Contracts\Connection;
    use Laravel\Reverb\Protocols\Pusher\Channels\Channel;
    use Laravel\Reverb\Protocols\Pusher\Channels\ChannelConnection;
    
    /**
     * @method static void dispatch(Channel $channel)
     * @method static PendingBroadcast broadcast(Channel $channel)
     */
    class ChannelCreated {}
    
    /**
     * @method static void dispatch(Channel $channel)
     * @method static PendingBroadcast broadcast(Channel $channel)
     */
    class ChannelRemoved {}
    
    /**
     * @method static void dispatch(ChannelConnection $connection)
     * @method static PendingBroadcast broadcast(ChannelConnection $connection)
     */
    class ConnectionPruned {}
    
    /**
     * @method static void dispatch(Connection $connection, string $message)
     * @method static PendingBroadcast broadcast(Connection $connection, string $message)
     */
    class MessageReceived {}
    
    /**
     * @method static void dispatch(Connection $connection, string $message)
     * @method static PendingBroadcast broadcast(Connection $connection, string $message)
     */
    class MessageSent {}
}

namespace Shetabit\Payment\Events {

    use Illuminate\Broadcasting\PendingBroadcast;
    use Shetabit\Multipay\Contracts\DriverInterface;
    use Shetabit\Multipay\Contracts\ReceiptInterface;
    use Shetabit\Multipay\Invoice;
    
    /**
     * @method static void dispatch(DriverInterface $driver, Invoice $invoice)
     * @method static PendingBroadcast broadcast(DriverInterface $driver, Invoice $invoice)
     */
    class InvoicePurchasedEvent {}
    
    /**
     * @method static void dispatch(ReceiptInterface $receipt, DriverInterface $driver, Invoice $invoice)
     * @method static PendingBroadcast broadcast(ReceiptInterface $receipt, DriverInterface $driver, Invoice $invoice)
     */
    class InvoiceVerifiedEvent {}
}

namespace Spatie\Permission\Events {

    use Illuminate\Database\Eloquent\Model;
    use Illuminate\Foundation\Bus\PendingDispatch;
    use Illuminate\Support\Collection;
    use Illuminate\Support\Fluent;
    use Spatie\Permission\Contracts\Permission;
    use Spatie\Permission\Contracts\Role;
    
    /**
     * @method static PendingDispatch dispatch(Model $model, array|Collection|int[]|Permission|Permission[]|string[] $permissionsOrIds)
     * @method static PendingDispatch|Fluent dispatchIf(boolean $bool, Model $model, array|Collection|int[]|Permission|Permission[]|string[] $permissionsOrIds)
     * @method static PendingDispatch|Fluent dispatchUnless(boolean $bool, Model $model, array|Collection|int[]|Permission|Permission[]|string[] $permissionsOrIds)
     * @method static mixed dispatchSync(Model $model, array|Collection|int[]|Permission|Permission[]|string[] $permissionsOrIds)
     * @method static void dispatchAfterResponse(Model $model, array|Collection|int[]|Permission|Permission[]|string[] $permissionsOrIds)
     */
    class PermissionAttached {}
    
    /**
     * @method static PendingDispatch dispatch(Model $model, array|Collection|int[]|Permission|Permission[]|string[] $permissionsOrIds)
     * @method static PendingDispatch|Fluent dispatchIf(boolean $bool, Model $model, array|Collection|int[]|Permission|Permission[]|string[] $permissionsOrIds)
     * @method static PendingDispatch|Fluent dispatchUnless(boolean $bool, Model $model, array|Collection|int[]|Permission|Permission[]|string[] $permissionsOrIds)
     * @method static mixed dispatchSync(Model $model, array|Collection|int[]|Permission|Permission[]|string[] $permissionsOrIds)
     * @method static void dispatchAfterResponse(Model $model, array|Collection|int[]|Permission|Permission[]|string[] $permissionsOrIds)
     */
    class PermissionDetached {}
    
    /**
     * @method static PendingDispatch dispatch(Model $model, array|Collection|int[]|Role|Role[]|string[] $rolesOrIds)
     * @method static PendingDispatch|Fluent dispatchIf(boolean $bool, Model $model, array|Collection|int[]|Role|Role[]|string[] $rolesOrIds)
     * @method static PendingDispatch|Fluent dispatchUnless(boolean $bool, Model $model, array|Collection|int[]|Role|Role[]|string[] $rolesOrIds)
     * @method static mixed dispatchSync(Model $model, array|Collection|int[]|Role|Role[]|string[] $rolesOrIds)
     * @method static void dispatchAfterResponse(Model $model, array|Collection|int[]|Role|Role[]|string[] $rolesOrIds)
     */
    class RoleAttached {}
    
    /**
     * @method static PendingDispatch dispatch(Model $model, array|Collection|int[]|Role|Role[]|string[] $rolesOrIds)
     * @method static PendingDispatch|Fluent dispatchIf(boolean $bool, Model $model, array|Collection|int[]|Role|Role[]|string[] $rolesOrIds)
     * @method static PendingDispatch|Fluent dispatchUnless(boolean $bool, Model $model, array|Collection|int[]|Role|Role[]|string[] $rolesOrIds)
     * @method static mixed dispatchSync(Model $model, array|Collection|int[]|Role|Role[]|string[] $rolesOrIds)
     * @method static void dispatchAfterResponse(Model $model, array|Collection|int[]|Role|Role[]|string[] $rolesOrIds)
     */
    class RoleDetached {}
}
