<?php
/* @noinspection ALL */
// @formatter:off
// phpcs:ignoreFile

/**
 * A helper file for Laravel, to provide autocomplete information to your IDE
 * Generated for Laravel 11.45.1.
 *
 * This file should not be included in your code, only analyzed by your IDE!
 *
 * @author Barry vd. Heuvel <barryvdh@gmail.com>
 * @see https://github.com/barryvdh/laravel-ide-helper
 */
namespace BplanBase\Globals\Facades {
    /**
     * AppLog Facade
     *
     * @version 2.0.0 / 2026-02-13
     * @author Emilio Cannarozzo <emilio.cannarozzo@bplan-solutions.de>
     * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
     */
    class AppLog {
        /**
         * @return string
         * @version 1.0.0 / 2025-08-03
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function alert(string|\Stringable $message, string|null $prefix = null, array|string $context = [], null|string $exceptionMessageIntro = null, \LogCode|null $code = null, \TraceCode|null $TraceCode = null): string
        {
            return \BplanBase\Globals\Logging\AppLog::alert($message, $prefix, $context, $exceptionMessageIntro, $code, $TraceCode);
        }

        /**
         * @return string
         * @version 1.0.0 / 2025-08-03
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function critical(string|\Stringable $message, string|null $prefix = null, array|string $context = [], null|string $exceptionMessageIntro = null, \LogCode|null $code = null, \TraceCode|null $TraceCode = null): string
        {
            return \BplanBase\Globals\Logging\AppLog::critical($message, $prefix, $context, $exceptionMessageIntro, $code, $TraceCode);
        }

        /**
         * @return string
         * @version 1.0.0 / 2025-08-03
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function debug(string|\Stringable $message, string|null $prefix = null, array|string $context = [], null|string $exceptionMessageIntro = null, \LogCode|null $code = null, \TraceCode|null $TraceCode = null): string
        {
            return \BplanBase\Globals\Logging\AppLog::debug($message, $prefix, $context, $exceptionMessageIntro, $code, $TraceCode);
        }

        /**
         * @return string
         * @version 1.0.0 / 2026-02-13
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function dump(mixed $params, \TraceCode|null $TraceCode = null): string
        {
            return \BplanBase\Globals\Logging\AppLog::info($params, null, [], null, $code, $TraceCode);
        }

        /**
         * @return string
         * @version 1.0.0 / 2025-08-03
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function emergency(string|\Stringable $message, string|null $prefix = null, array|string $context = [], null|string $exceptionMessageIntro = null, \LogCode|null $code = null, \TraceCode|null $TraceCode = null): string
        {
            return \BplanBase\Globals\Logging\AppLog::emergency($message, $prefix, $context, $exceptionMessageIntro, $code, $TraceCode);
        }

        /**
         * @return string
         * @version 1.0.0 / 2025-08-03
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function error(string|\Stringable $message, string|null $prefix = null, array|string $context = [], null|string $exceptionMessageIntro = null, \LogCode|null $code = null, \TraceCode|null $TraceCode = null): string
        {
            return \BplanBase\Globals\Logging\AppLog::error($message, $prefix, $context, $exceptionMessageIntro, $code, $TraceCode);
        }

        /**
         * @return string
         * @version 1.0.0 / 2025-08-03
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function info(string|\Stringable $message, string|null $prefix = null, array|string $context = [], null|string $exceptionMessageIntro = null, \LogCode|null $code = null, \TraceCode|null $TraceCode = null): string
        {
            return \BplanBase\Globals\Logging\AppLog::info($message, $prefix, $context, $exceptionMessageIntro, $code, $TraceCode);
        }

        /**
         * @return string
         * @version 1.0.0 / 2025-08-03
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function notice(string|\Stringable $message, string|null $prefix = null, array|string $context = [], null|string $exceptionMessageIntro = null, \LogCode|null $code = null, \TraceCode|null $TraceCode = null): string
        {
            return \BplanBase\Globals\Logging\AppLog::notice($message, $prefix, $context, $exceptionMessageIntro, $code, $TraceCode);
        }

        /**
         * @return string
         * @version 1.0.0 / 2025-08-03
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function warning(string|\Stringable $message, string|null $prefix = null, array|string $context = [], null|string $exceptionMessageIntro = null, \LogCode|null $code = null, \TraceCode|null $TraceCode = null): string
        {
            return \BplanBase\Globals\Logging\AppLog::warning($message, $prefix, $context, $exceptionMessageIntro, $code, $TraceCode);
        }
    }

    /**
     * Registry Facade
     *
     * @version 3.0.0 / 2025-07-16
     * @author Emilio Cannarozzo <emilio.cannarozzo@bplan-solutions.de>
     * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
     */
    class Registry {
        /**
         * @return array
         * @version 1.0.0 / 2025-05-20
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function all(): array
        {
            return \BplanBase\Globals\Registries\Registry::all();
        }

        /**
         * @param string $key
         * @param bool $force
         * @return mixed
         * @version 1.0.0 / 2025-05-19
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function forget(string $key, bool $force = false): mixed
        {
            return \BplanBase\Globals\Registries\Registry::forget($key, $force);
        }

        /**
         * @return array
         * @version 1.1.0 / 2025-07-16
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function flush(): array
        {
            return \BplanBase\Globals\Registries\Registry::flush();
        }

        /**
         * @param string $key
         * @param mixed $default
         * @return mixed
         * @version 1.0.0 / 2025-05-19
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function get(string $key, mixed $default = null): mixed
        {
            return \BplanBase\Globals\Registries\Registry::get($key, $default);
        }

        /**
         * @param string $key
         * @param mixed $default
         * @return void
         * @version 1.0.0 / 2025-07-16
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function has(string $key, mixed $default = null): bool
        {
            return \BplanBase\Globals\Registries\Registry::has($key, $default);
        }

        /**
         * @param string $key
         * @param mixed $value
         * @param bool $readonly
         * @throws RuntimeException
         * @return void
         * @version 1.0.0 / 2025-05-19
         * @author Wassilios Meletiadis <wassilios.meletiadis@bplan-solutions.de>
         * @static
         */
        public static function put(string $key, mixed $value, bool $readonly = false): void
        {
            \BplanBase\Globals\Registries\Registry::put($key, $value, $readonly);
        }

    }
}

namespace LaravelJsonApi\Core\Facades {
    /**
     * Class JsonApi
     *
     */
    class JsonApi {
        /**
         * @return \LaravelJsonApi\Contracts\Routing\Route
         * @static
         */
        public static function route()
        {
            /** @var \LaravelJsonApi\Core\JsonApiService $instance */
            return $instance->route();
        }

        /**
         * Get the active server, or a named server.
         *
         * @param string|null $name
         * @return \LaravelJsonApi\Contracts\Server\Server
         * @static
         */
        public static function server($name = null)
        {
            /** @var \LaravelJsonApi\Core\JsonApiService $instance */
            return $instance->server($name);
        }

        /**
         * Get the active server, if there is one.
         *
         * @return \LaravelJsonApi\Contracts\Server\Server|null
         * @static
         */
        public static function serverIfExists()
        {
            /** @var \LaravelJsonApi\Core\JsonApiService $instance */
            return $instance->serverIfExists();
        }

            }
    }

namespace LaravelJsonApi\Laravel\Facades {
    /**
     * Class JsonApiRoute
     *
     */
    class JsonApiRoute {
        /**
         * Register routes for the named JSON API server.
         *
         * @param string $name
         * @return \LaravelJsonApi\Laravel\Routing\PendingServerRegistration
         * @static
         */
        public static function server($name)
        {
            /** @var \LaravelJsonApi\Laravel\Routing\Registrar $instance */
            return $instance->server($name);
        }

            }
    }

namespace Livewire {
    /**
     * @see \Livewire\LivewireManager
     */
    class Livewire {
        /**
         * @static
         */
        public static function setProvider($provider)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->setProvider($provider);
        }

        /**
         * @static
         */
        public static function provide($callback)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->provide($callback);
        }

        /**
         * @static
         */
        public static function component($name, $class = null)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->component($name, $class);
        }

        /**
         * @static
         */
        public static function componentHook($hook)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->componentHook($hook);
        }

        /**
         * @static
         */
        public static function propertySynthesizer($synth)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->propertySynthesizer($synth);
        }

        /**
         * @static
         */
        public static function directive($name, $callback)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->directive($name, $callback);
        }

        /**
         * @static
         */
        public static function precompiler($callback)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->precompiler($callback);
        }

        /**
         * @static
         */
        public static function new($name, $id = null)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->new($name, $id);
        }

        /**
         * @static
         */
        public static function isDiscoverable($componentNameOrClass)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->isDiscoverable($componentNameOrClass);
        }

        /**
         * @static
         */
        public static function resolveMissingComponent($resolver)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->resolveMissingComponent($resolver);
        }

        /**
         * @static
         */
        public static function mount($name, $params = [], $key = null)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->mount($name, $params, $key);
        }

        /**
         * @static
         */
        public static function snapshot($component)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->snapshot($component);
        }

        /**
         * @static
         */
        public static function fromSnapshot($snapshot)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->fromSnapshot($snapshot);
        }

        /**
         * @static
         */
        public static function listen($eventName, $callback)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->listen($eventName, $callback);
        }

        /**
         * @static
         */
        public static function current()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->current();
        }

        /**
         * @static
         */
        public static function findSynth($keyOrTarget, $component)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->findSynth($keyOrTarget, $component);
        }

        /**
         * @static
         */
        public static function update($snapshot, $diff, $calls)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->update($snapshot, $diff, $calls);
        }

        /**
         * @static
         */
        public static function updateProperty($component, $path, $value)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->updateProperty($component, $path, $value);
        }

        /**
         * @static
         */
        public static function isLivewireRequest()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->isLivewireRequest();
        }

        /**
         * @static
         */
        public static function componentHasBeenRendered()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->componentHasBeenRendered();
        }

        /**
         * @static
         */
        public static function forceAssetInjection()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->forceAssetInjection();
        }

        /**
         * @static
         */
        public static function setUpdateRoute($callback)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->setUpdateRoute($callback);
        }

        /**
         * @static
         */
        public static function getUpdateUri()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->getUpdateUri();
        }

        /**
         * @static
         */
        public static function setScriptRoute($callback)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->setScriptRoute($callback);
        }

        /**
         * @static
         */
        public static function useScriptTagAttributes($attributes)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->useScriptTagAttributes($attributes);
        }

        /**
         * @static
         */
        public static function withUrlParams($params)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->withUrlParams($params);
        }

        /**
         * @static
         */
        public static function withQueryParams($params)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->withQueryParams($params);
        }

        /**
         * @static
         */
        public static function withCookie($name, $value)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->withCookie($name, $value);
        }

        /**
         * @static
         */
        public static function withCookies($cookies)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->withCookies($cookies);
        }

        /**
         * @static
         */
        public static function withHeaders($headers)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->withHeaders($headers);
        }

        /**
         * @static
         */
        public static function withoutLazyLoading()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->withoutLazyLoading();
        }

        /**
         * @static
         */
        public static function test($name, $params = [])
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->test($name, $params);
        }

        /**
         * @static
         */
        public static function visit($name)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->visit($name);
        }

        /**
         * @static
         */
        public static function actingAs($user, $driver = null)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->actingAs($user, $driver);
        }

        /**
         * @static
         */
        public static function isRunningServerless()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->isRunningServerless();
        }

        /**
         * @static
         */
        public static function addPersistentMiddleware($middleware)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->addPersistentMiddleware($middleware);
        }

        /**
         * @static
         */
        public static function setPersistentMiddleware($middleware)
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->setPersistentMiddleware($middleware);
        }

        /**
         * @static
         */
        public static function getPersistentMiddleware()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->getPersistentMiddleware();
        }

        /**
         * @static
         */
        public static function flushState()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->flushState();
        }

        /**
         * @static
         */
        public static function originalUrl()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->originalUrl();
        }

        /**
         * @static
         */
        public static function originalPath()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->originalPath();
        }

        /**
         * @static
         */
        public static function originalMethod()
        {
            /** @var \Livewire\LivewireManager $instance */
            return $instance->originalMethod();
        }

            }
    }

namespace Maatwebsite\Excel\Facades {
    /**
     */
    class Excel {
        /**
         * @param object $export
         * @param string|null $fileName
         * @param string $writerType
         * @param array $headers
         * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
         * @throws \PhpOffice\PhpSpreadsheet\Exception
         * @throws \PhpOffice\PhpSpreadsheet\Writer\Exception
         * @static
         */
        public static function download($export, $fileName, $writerType = null, $headers = [])
        {
            /** @var \Maatwebsite\Excel\Excel $instance */
            return $instance->download($export, $fileName, $writerType, $headers);
        }

        /**
         * @param string|null $disk Fallback for usage with named properties
         * @param object $export
         * @param string $filePath
         * @param string|null $diskName
         * @param string $writerType
         * @param mixed $diskOptions
         * @return bool
         * @throws \PhpOffice\PhpSpreadsheet\Exception
         * @throws \PhpOffice\PhpSpreadsheet\Writer\Exception
         * @static
         */
        public static function store($export, $filePath, $diskName = null, $writerType = null, $diskOptions = [], $disk = null)
        {
            /** @var \Maatwebsite\Excel\Excel $instance */
            return $instance->store($export, $filePath, $diskName, $writerType, $diskOptions, $disk);
        }

        /**
         * @param object $export
         * @param string $filePath
         * @param string|null $disk
         * @param string $writerType
         * @param mixed $diskOptions
         * @return \Illuminate\Foundation\Bus\PendingDispatch
         * @static
         */
        public static function queue($export, $filePath, $disk = null, $writerType = null, $diskOptions = [])
        {
            /** @var \Maatwebsite\Excel\Excel $instance */
            return $instance->queue($export, $filePath, $disk, $writerType, $diskOptions);
        }

        /**
         * @param object $export
         * @param string $writerType
         * @return string
         * @static
         */
        public static function raw($export, $writerType)
        {
            /** @var \Maatwebsite\Excel\Excel $instance */
            return $instance->raw($export, $writerType);
        }

        /**
         * @param object $import
         * @param string|\Symfony\Component\HttpFoundation\File\UploadedFile $filePath
         * @param string|null $disk
         * @param string|null $readerType
         * @return \Maatwebsite\Excel\Reader|\Illuminate\Foundation\Bus\PendingDispatch
         * @static
         */
        public static function import($import, $filePath, $disk = null, $readerType = null)
        {
            /** @var \Maatwebsite\Excel\Excel $instance */
            return $instance->import($import, $filePath, $disk, $readerType);
        }

        /**
         * @param object $import
         * @param string|\Symfony\Component\HttpFoundation\File\UploadedFile $filePath
         * @param string|null $disk
         * @param string|null $readerType
         * @return array
         * @static
         */
        public static function toArray($import, $filePath, $disk = null, $readerType = null)
        {
            /** @var \Maatwebsite\Excel\Excel $instance */
            return $instance->toArray($import, $filePath, $disk, $readerType);
        }

        /**
         * @param object $import
         * @param string|\Symfony\Component\HttpFoundation\File\UploadedFile $filePath
         * @param string|null $disk
         * @param string|null $readerType
         * @return \Illuminate\Support\Collection
         * @static
         */
        public static function toCollection($import, $filePath, $disk = null, $readerType = null)
        {
            /** @var \Maatwebsite\Excel\Excel $instance */
            return $instance->toCollection($import, $filePath, $disk, $readerType);
        }

        /**
         * @param \Illuminate\Contracts\Queue\ShouldQueue $import
         * @param string|\Symfony\Component\HttpFoundation\File\UploadedFile $filePath
         * @param string|null $disk
         * @param string $readerType
         * @return \Illuminate\Foundation\Bus\PendingDispatch
         * @static
         */
        public static function queueImport($import, $filePath, $disk = null, $readerType = null)
        {
            /** @var \Maatwebsite\Excel\Excel $instance */
            return $instance->queueImport($import, $filePath, $disk, $readerType);
        }

        /**
         * Register a custom macro.
         *
         * @param string $name
         * @param object|callable $macro
         * @param-closure-this static  $macro
         * @return void
         * @static
         */
        public static function macro($name, $macro)
        {
            \Maatwebsite\Excel\Excel::macro($name, $macro);
        }

        /**
         * Mix another object into the class.
         *
         * @param object $mixin
         * @param bool $replace
         * @return void
         * @throws \ReflectionException
         * @static
         */
        public static function mixin($mixin, $replace = true)
        {
            \Maatwebsite\Excel\Excel::mixin($mixin, $replace);
        }

        /**
         * Checks if macro is registered.
         *
         * @param string $name
         * @return bool
         * @static
         */
        public static function hasMacro($name)
        {
            return \Maatwebsite\Excel\Excel::hasMacro($name);
        }

        /**
         * Flush the existing macros.
         *
         * @return void
         * @static
         */
        public static function flushMacros()
        {
            \Maatwebsite\Excel\Excel::flushMacros();
        }

        /**
         * @param string $concern
         * @param callable $handler
         * @param string $event
         * @static
         */
        public static function extend($concern, $handler, $event = 'Maatwebsite\\Excel\\Events\\BeforeWriting')
        {
            return \Maatwebsite\Excel\Excel::extend($concern, $handler, $event);
        }

        /**
         * When asserting downloaded, stored, queued or imported, use regular expression
         * to look for a matching file path.
         *
         * @return void
         * @static
         */
        public static function matchByRegex()
        {
            /** @var \Maatwebsite\Excel\Fakes\ExcelFake $instance */
            $instance->matchByRegex();
        }

        /**
         * When asserting downloaded, stored, queued or imported, use regular string
         * comparison for matching file path.
         *
         * @return void
         * @static
         */
        public static function doNotMatchByRegex()
        {
            /** @var \Maatwebsite\Excel\Fakes\ExcelFake $instance */
            $instance->doNotMatchByRegex();
        }

        /**
         * @param string $fileName
         * @param callable|null $callback
         * @static
         */
        public static function assertDownloaded($fileName, $callback = null)
        {
            /** @var \Maatwebsite\Excel\Fakes\ExcelFake $instance */
            return $instance->assertDownloaded($fileName, $callback);
        }

        /**
         * @param string $filePath
         * @param string|callable|null $disk
         * @param callable|null $callback
         * @static
         */
        public static function assertStored($filePath, $disk = null, $callback = null)
        {
            /** @var \Maatwebsite\Excel\Fakes\ExcelFake $instance */
            return $instance->assertStored($filePath, $disk, $callback);
        }

        /**
         * @param string $filePath
         * @param string|callable|null $disk
         * @param callable|null $callback
         * @static
         */
        public static function assertQueued($filePath, $disk = null, $callback = null)
        {
            /** @var \Maatwebsite\Excel\Fakes\ExcelFake $instance */
            return $instance->assertQueued($filePath, $disk, $callback);
        }

        /**
         * @static
         */
        public static function assertQueuedWithChain($chain)
        {
            /** @var \Maatwebsite\Excel\Fakes\ExcelFake $instance */
            return $instance->assertQueuedWithChain($chain);
        }

        /**
         * @param string $classname
         * @param callable|null $callback
         * @static
         */
        public static function assertExportedInRaw($classname, $callback = null)
        {
            /** @var \Maatwebsite\Excel\Fakes\ExcelFake $instance */
            return $instance->assertExportedInRaw($classname, $callback);
        }

        /**
         * @param string $filePath
         * @param string|callable|null $disk
         * @param callable|null $callback
         * @static
         */
        public static function assertImported($filePath, $disk = null, $callback = null)
        {
            /** @var \Maatwebsite\Excel\Fakes\ExcelFake $instance */
            return $instance->assertImported($filePath, $disk, $callback);
        }

            }
    }

namespace Sajya\Server\Facades {
    /**
     * Class RPC
     *
     * @see \Sajya\Server\Binding
     */
    class RPC {
        /**
         * Register a model binder for a wildcard.
         *
         * @param string $key
         * @param string $class
         * @param \Closure|null $callback
         * @return void
         * @static
         */
        public static function model($key, $class, $callback = null)
        {
            /** @var \Sajya\Server\Binding $instance */
            $instance->model($key, $class, $callback);
        }

        /**
         * Add a new route parameter binder.
         *
         * @param string $key
         * @param \Closure|string $binder
         * @return void
         * @static
         */
        public static function bind($key, $binder)
        {
            /** @var \Sajya\Server\Binding $instance */
            $instance->bind($key, $binder);
        }

        /**
         * Binds the values of the given parameters to their corresponding type.
         *
         * @param string $procedure
         * @param \Illuminate\Support\Collection $params
         * @throws \ReflectionException
         * @return array
         * @static
         */
        public static function bindResolve($procedure, $params)
        {
            /** @var \Sajya\Server\Binding $instance */
            return $instance->bindResolve($procedure, $params);
        }

            }
    }

namespace Illuminate\Support {
    /**
     * @template TKey of array-key
     * @template-covariant TValue
     * @implements \ArrayAccess<TKey, TValue>
     * @implements \Illuminate\Support\Enumerable<TKey, TValue>
     */
    class Collection {
        /**
         * @see \Maatwebsite\Excel\Mixins\DownloadCollectionMixin::downloadExcel()
         * @param string $fileName
         * @param string|null $writerType
         * @param mixed $withHeadings
         * @param array $responseHeaders
         * @static
         */
        public static function downloadExcel($fileName, $writerType = null, $withHeadings = false, $responseHeaders = [])
        {
            return \Illuminate\Support\Collection::downloadExcel($fileName, $writerType, $withHeadings, $responseHeaders);
        }

        /**
         * @see \Maatwebsite\Excel\Mixins\StoreCollectionMixin::storeExcel()
         * @param string $filePath
         * @param string|null $disk
         * @param string|null $writerType
         * @param mixed $withHeadings
         * @static
         */
        public static function storeExcel($filePath, $disk = null, $writerType = null, $withHeadings = false)
        {
            return \Illuminate\Support\Collection::storeExcel($filePath, $disk, $writerType, $withHeadings);
        }

            }
    }

namespace Illuminate\Http {
    /**
     */
    class Request extends \Symfony\Component\HttpFoundation\Request {
        /**
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
         * @param array $rules
         * @param mixed $params
         * @static
         */
        public static function validate($rules, ...$params)
        {
            return \Illuminate\Http\Request::validate($rules, ...$params);
        }

        /**
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
         * @param string $errorBag
         * @param array $rules
         * @param mixed $params
         * @static
         */
        public static function validateWithBag($errorBag, $rules, ...$params)
        {
            return \Illuminate\Http\Request::validateWithBag($errorBag, $rules, ...$params);
        }

        /**
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
         * @param mixed $absolute
         * @static
         */
        public static function hasValidSignature($absolute = true)
        {
            return \Illuminate\Http\Request::hasValidSignature($absolute);
        }

        /**
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
         * @static
         */
        public static function hasValidRelativeSignature()
        {
            return \Illuminate\Http\Request::hasValidRelativeSignature();
        }

        /**
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
         * @param mixed $ignoreQuery
         * @param mixed $absolute
         * @static
         */
        public static function hasValidSignatureWhileIgnoring($ignoreQuery = [], $absolute = true)
        {
            return \Illuminate\Http\Request::hasValidSignatureWhileIgnoring($ignoreQuery, $absolute);
        }

        /**
         * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
         * @param mixed $ignoreQuery
         * @static
         */
        public static function hasValidRelativeSignatureWhileIgnoring($ignoreQuery = [])
        {
            return \Illuminate\Http\Request::hasValidRelativeSignatureWhileIgnoring($ignoreQuery);
        }

            }
    /**
     */
    class RedirectResponse extends \Symfony\Component\HttpFoundation\RedirectResponse {
        /**
         * @see \Laravel\Jetstream\JetstreamServiceProvider::boot()
         * @param mixed $message
         * @return \Illuminate\Http\RedirectResponse
         * @static
         */
        public static function banner($message)
        {
            return \Illuminate\Http\RedirectResponse::banner($message);
        }

        /**
         * @see \Laravel\Jetstream\JetstreamServiceProvider::boot()
         * @param mixed $message
         * @return \Illuminate\Http\RedirectResponse
         * @static
         */
        public static function warningBanner($message)
        {
            return \Illuminate\Http\RedirectResponse::warningBanner($message);
        }

        /**
         * @see \Laravel\Jetstream\JetstreamServiceProvider::boot()
         * @param mixed $message
         * @return \Illuminate\Http\RedirectResponse
         * @static
         */
        public static function dangerBanner($message)
        {
            return \Illuminate\Http\RedirectResponse::dangerBanner($message);
        }

            }
    }

namespace Illuminate\Validation {
    /**
     */
    class Rule {
        /**
         * @see \Propaganistas\LaravelPhone\PhoneServiceProvider::registerValidator()
         * @static
         */
        public static function phone()
        {
            return \Illuminate\Validation\Rule::phone();
        }

            }
    }

namespace Illuminate\Routing {
    /**
     * @mixin \Illuminate\Routing\RouteRegistrar
     */
    class Router {
        /**
         * @see \Sajya\Server\ServerServiceProvider::register()
         * @param string $uri
         * @param array $procedures
         * @param string|null $delimiter
         * @static
         */
        public static function rpc($uri, $procedures = [], $delimiter = null)
        {
            return \Illuminate\Routing\Router::rpc($uri, $procedures, $delimiter);
        }

            }
    /**
     */
    class Route {
        /**
         * @see \Livewire\Features\SupportLazyLoading\SupportLazyLoading::registerRouteMacro()
         * @param mixed $enabled
         * @static
         */
        public static function lazy($enabled = true)
        {
            return \Illuminate\Routing\Route::lazy($enabled);
        }

            }
    }

namespace Illuminate\View {
    /**
     */
    class ComponentAttributeBag {
        /**
         * @see \Livewire\Features\SupportBladeAttributes\SupportBladeAttributes::provide()
         * @param mixed $name
         * @static
         */
        public static function wire($name)
        {
            return \Illuminate\View\ComponentAttributeBag::wire($name);
        }

            }
    /**
     */
    class View {
        /**
         * @see \Livewire\Features\SupportPageComponents\SupportPageComponents::registerLayoutViewMacros()
         * @param mixed $data
         * @static
         */
        public static function layoutData($data = [])
        {
            return \Illuminate\View\View::layoutData($data);
        }

        /**
         * @see \Livewire\Features\SupportPageComponents\SupportPageComponents::registerLayoutViewMacros()
         * @param mixed $section
         * @static
         */
        public static function section($section)
        {
            return \Illuminate\View\View::section($section);
        }

        /**
         * @see \Livewire\Features\SupportPageComponents\SupportPageComponents::registerLayoutViewMacros()
         * @param mixed $title
         * @static
         */
        public static function title($title)
        {
            return \Illuminate\View\View::title($title);
        }

        /**
         * @see \Livewire\Features\SupportPageComponents\SupportPageComponents::registerLayoutViewMacros()
         * @param mixed $slot
         * @static
         */
        public static function slot($slot)
        {
            return \Illuminate\View\View::slot($slot);
        }

        /**
         * @see \Livewire\Features\SupportPageComponents\SupportPageComponents::registerLayoutViewMacros()
         * @param mixed $view
         * @param mixed $params
         * @static
         */
        public static function extends($view, $params = [])
        {
            return \Illuminate\View\View::extends($view, $params);
        }

        /**
         * @see \Livewire\Features\SupportPageComponents\SupportPageComponents::registerLayoutViewMacros()
         * @param mixed $view
         * @param mixed $params
         * @static
         */
        public static function layout($view, $params = [])
        {
            return \Illuminate\View\View::layout($view, $params);
        }

        /**
         * @see \Livewire\Features\SupportPageComponents\SupportPageComponents::registerLayoutViewMacros()
         * @param callable $callback
         * @static
         */
        public static function response($callback)
        {
            return \Illuminate\View\View::response($callback);
        }

            }
    }


namespace  {
    class AppLog extends \BplanBase\Globals\Facades\AppLog {}
    class Registry extends \BplanBase\Globals\Facades\Registry {}
    class JsonApi extends \LaravelJsonApi\Core\Facades\JsonApi {}
    class JsonApiRoute extends \LaravelJsonApi\Laravel\Facades\JsonApiRoute {}
    class Livewire extends \Livewire\Livewire {}
    class Excel extends \Maatwebsite\Excel\Facades\Excel {}
    class RPC extends \Sajya\Server\Facades\RPC {}
}


namespace Facades\Livewire\Features\SupportFileUploads {
    /**
     * @mixin \Livewire\Features\SupportFileUploads\GenerateSignedUploadUrl     */
    class GenerateSignedUploadUrl extends \Livewire\Features\SupportFileUploads\GenerateSignedUploadUrl {}
}



