ConfigValidator $io

CurlResponse $curlInfo

JsonValidationException $errors

IgnoredSecurityAdvisory $ignoreReason

JsonLoader $loader

MarkAliasInstalledOperation $package

MarkAliasUninstalledOperation $package

LockTransaction $resultPackages

GenericRule $literals

CompositeRepository $repositories

FilterRepository $repo

AuthHelper $io

AuthHelper $config

GitLab $io

GitLab $config

Hg $process

ErrorHandler $io

Versions $config

HhvmDetector $hhvmVersion = null

HhvmDetector $executableFinder

HhvmDetector $processExecutor

PreCommandRunEvent $input

PreCommandRunEvent $command

RuleWatchGraph $watchChains = [ ]

Rule2Literals $literal1

Rule2Literals $literal2

RuleWatchNode $watch2

RuleSetIterator $rules

RuleSetIterator $currentType

InstallOperation $package

UninstallOperation $package

IgnoreListPlatformRequirementFilter $ignoreRegex

IgnoreListPlatformRequirementFilter $ignoreUpperBoundRegex

SecurityAdvisory $title

SecurityAdvisory $cve

SecurityAdvisory $link

SecurityAdvisory $reportedAt

SecurityAdvisory $sources

SecurityAdvisory $severity

CompleteAliasPackage $aliasOf

RootAliasPackage $aliasOf

PharArchiver $formats = ['zip' => \Phar::ZIP, 'tar' => \Phar::TAR, 'tar.gz' => \Phar::TAR, 'tar.bz2' => \Phar::TAR, ]

InputArgument $suggestedValues

Cache $root

MultiConflictRule $literals

RuleSetIterator $currentOffset

AliasPackage $aliasOf

VersionGuesser $process

VersionGuesser $versionParser

Loop $httpDownloader

Loop $processExecutor

ProxyManager $hasProxy

SolverProblemsException $problems

RuleWatchNode $watch1

RuleWatchNode $rule

UpdateOperation $initialPackage

UpdateOperation $targetPackage

Bitbucket $io

Bitbucket $config

Bitbucket $token = null

PackageRepository $config

Silencer $stack = [ ]

Hg $io

Hg $config

CommandEvent $commandName

CommandEvent $input

CommandEvent $output

Decisions $decisionQueue = [ ]

BinaryInstaller $filesystem

ProjectInstaller $installPath

Link $target

Link $constraint

Link $description

ArchivableFilesFilter $dirs = [ ]

InvalidPackageException $errors

InvalidPackageException $warnings

InvalidPackageException $data

GithubActionError $io

InputOption $suggestedValues

Response $headers

Git $process

WritableArrayRepository $devMode = null

PathRepository $url

PathRepository $repoConfig

HgDriver $repoDir

GitBitbucketDriver $fallbackDriver = null

GitDriver $repoDir

RuleSetIterator $types

ScriptAliasCommand $script

ValidatingArrayLoader $errors

ValidatingArrayLoader $config

Solver $decisions

JsonManipulator $contents

BasePackage $stabilities = ['stable' => self::STABILITY_STABLE, 'RC' => self::STABILITY_RC, 'beta' => self::STABILITY_BETA, 'alpha' => self::STABILITY_ALPHA, 'dev' => self::STABILITY_DEV, ]

ProjectInstaller $downloadManager

GitHubDriver $owner

GitHubDriver $repository

Cache $allowlist

Cache $readOnly

Compiler $version

Compiler $versionDate

ConfigReturnTypeExtension $properties = [ ]

ArtifactRepository $lookup

ArtifactRepository $io

PerforceDriver $perforce = null

FossilDriver $checkoutDir

GitHub $io

GitHub $config

GitHub $process

GitLab $httpDownloader

Loop $currentPromises = [ ]

Response $body

RequestProxy $contextOptions

RequestProxy $isSecure

RequestProxy $formattedUrl

RequestProxy $url

Versions $httpDownloader

Versions $channel

LockTransaction $presentMap

LockTransaction $unlockableMap

JsonFile $path

SolverProblemsException $learnedPool

RuleSetGenerator $pool

Decisions $decisionMap

PartialSecurityAdvisory $advisoryId

PartialSecurityAdvisory $packageName

PartialSecurityAdvisory $affectedVersions

Link $source

ArchivableFilesFinder $finder

PharArchiver $compressFormats = ['tar.gz' => \Phar::GZ, 'tar.bz2' => \Phar::BZ2, ]

BaseExcludeFilter $excludePatterns

VersionSelector $repositorySet

VersionSelector $platformConstraints = [ ]

ValidatingArrayLoader $warnings

ArrayLoader $versionParser

RootPackageLoader $manager

RootPackageLoader $config

RootPackageLoader $versionGuesser

RootPackageLoader $io

HtmlOutputFormatter $availableForegroundColors = [30 => 'black', 31 => 'red', 32 => 'green', 33 => 'yellow', 34 => 'blue', 35 => 'magenta', 36 => 'cyan', 37 => 'white', ]

HtmlOutputFormatter $availableBackgroundColors = [40 => 'black', 41 => 'red', 42 => 'green', 43 => 'yellow', 44 => 'blue', 45 => 'magenta', 46 => 'cyan', 47 => 'white', ]

HtmlOutputFormatter $availableOptions = [1 => 'bold', 4 => 'underscore', ]

GitHubDriver $gitDriver = null

RepositoryManager $repositories = [ ]

Rule $bitfield

RuleSet $rules

BinaryInstaller $binDir

MetapackageInstaller $io

SvnDriver $baseUrl

JsonManipulator $newline

JsonManipulator $indent

PluginManager $composer

Transaction $operations

PoolOptimizer $irremovablePackages = [ ]

PoolOptimizer $aliasesPerPackage = [ ]

PoolBuilder $io

PoolBuilder $loadedPackages = [ ]

PoolBuilder $packages = [ ]

WritableArrayRepository $devPackageNames = [ ]

RepositorySet $repositories = [ ]

PathRepository $loader

PathRepository $versionGuesser

PathRepository $process

PathRepository $options

Event $name

Event $args

Event $flags

Event $propagationStopped = false

FileDownloader $io

FileDownloader $filesystem

PerforceDownloader $perforce

StrictConfirmationQuestion $trueAnswerRegex

StrictConfirmationQuestion $falseAnswerRegex

RuleSetGenerator $addedMap = [ ]

RuleSetIterator $currentTypeOffset

ScriptAliasCommand $description

ScriptAliasCommand $aliases

InstallerEvent $composer

InstallerEvent $io

InstallerEvent $devMode

InstallerEvent $executeOperations

InstallerEvent $transaction

ArrayRepository $packages = null

Pool $packages = [ ]

ProxyManager $error = null

ProxyManager $fullProxy

ProxyManager $safeProxy

ProxyManager $streams

Response $request

Response $code

SuggestedPackagesReporter $io

ArchiveManager $archivers = [ ]

GitLabDriver $gitDriver = null

CurlDownloader $multiHandle

CurlDownloader $io

CurlDownloader $config

CurlDownloader $authHelper

JsonConfigSource $authConfig

ConsoleIO $output

Solver $pool

Solver $rules

GitBitbucketDriver $owner

GitBitbucketDriver $repository

Request $fixedPackages = [ ]

Cache $io

Cache $filesystem

Compiler $branchAliasVersion = ''

ArtifactRepository $loader

ArtifactRepository $repoConfig

Svn $credentials

GitHub $httpDownloader

GitLab $process

Hg $version = false

EventDispatcher $composer

EventDispatcher $io

BufferIO $input

BufferIO $output

PreFileDownloadEvent $processedUrl

PostFileDownloadEvent $fileName

PostFileDownloadEvent $checksum

PostFileDownloadEvent $url

PostFileDownloadEvent $context

PostFileDownloadEvent $type

SvnDownloader $cacheCredentials = true

FileDownloader $config

ZipDownloader $unzipCommands

ZipDownloader $hasZipArchive

Event $composer

Event $io

Event $devMode

Event $originatingEvent

PoolOptimizer $requireConstraintsPerPackage = [ ]

PoolOptimizer $packagesToRemove = [ ]

PoolBuilder $skippedLoad = [ ]

PoolBuilder $pathRepoUnlocked = [ ]

ConfigCommand $config

ConfigCommand $configSource

DiagnoseCommand $httpDownloader

BinaryInstaller $io

PackageEvent $composer

PackageEvent $io

PackageEvent $devMode

PackageEvent $localRepo

PackageEvent $operations

PackageEvent $operation

Link $TYPES = [self::TYPE_REQUIRE, self::TYPE_DEV_REQUIRE, self::TYPE_PROVIDE, self::TYPE_CONFLICT, self::TYPE_REPLACE, ]

Link $prettyConstraint

ZipArchiver $formats = ['zip' => true, ]

VersionParser $constraints = [ ]

Comparer $source

Comparer $update

Comparer $changed

ConsoleIO $input

VcsRepository $url

RemoteFilesystem $fileUrl

LibraryInstaller $filesystem

LibraryInstaller $binaryInstaller

FilesystemRepository $filesystem

Git $io

Application $io

ComposerRepository $cache

ComposerRepository $lazyProvidersUrl = null

PluginManager $globalComposer

Config $config

PrePoolCreateEvent $packages

PrePoolCreateEvent $unacceptableFixedPackages

RuleSetGenerator $rules

RuleSetGenerator $addedPackagesByNames = [ ]

HttpDownloader $curl

VcsDownloader $io

PlatformRepository $versionParser

Bitbucket $process

Bitbucket $httpDownloader

Bitbucket $time

Solver $problems = [ ]

DefaultPolicy $preferStable

DefaultPolicy $preferLowest

DefaultPolicy $preferredVersions

Transaction $presentPackages

Transaction $resultPackageMap

Transaction $resultPackagesByName = [ ]

Problem $reasons = [ ]

Locker $lockFile

CurlDownloader $jobs = [ ]

JsonConfigSource $file

ConsoleIO $helperSet

RepositorySet $acceptableStabilities

RepositorySet $stabilityFlags

Svn $hasAuth

Svn $io

Svn $url

PluginManager $io

VcsRepository $io

ComposerRepository $options

ComposerRepository $partialPackagesByName = null

PerforceDriver $depot

AuthHelper $displayedOriginAuthentications = [ ]

AuthHelper $bitbucketRetry = [ ]

RemoteFilesystem $io

RemoteFilesystem $options = [ ]

RemoteFilesystem $authHelper

Loop $waitIndex = 0

ProxyManager $info = null

ProxyManager $noProxyHandler = null

ProxyManager $instance = null

Versions $versionsData = null

BaseIO $authentications = [ ]

TransportException $headers

TransportException $response

TransportException $statusCode

TransportException $responseInfo = [ ]

Request $lockedPackages = [ ]

PoolOptimizer $conflictConstraintsPerPackage = [ ]

PoolOptimizer $removedVersionsByPackage = [ ]

PoolBuilder $acceptableStabilities

PoolBuilder $stabilityFlags

PoolBuilder $rootAliases

PoolBuilder $rootReferences

PoolBuilder $aliasMap = [ ]

PoolBuilder $packagesToLoad = [ ]

PoolBuilder $loadedPerRepo = [ ]

PoolBuilder $updateAllowList = [ ]

PoolBuilder $maxExtendedReqs = [ ]

SuggestedPackagesReporter $suggestedPackages = [ ]

ArchiveManager $downloadManager

ArchiveManager $loop

ArchiveManager $overwriteFiles = true

BaseExcludeFilter $sourcePath

VersionSelector $parser

ArrayLoader $loadOptions

BasePackage $supportedLinkTypes = ['require' => ['description' => 'requires', 'method' => Link::TYPE_REQUIRE], 'conflict' => ['description' => 'conflicts', 'method' => Link::TYPE_CONFLICT], 'provide' => ['description' => 'provides', 'method' => Link::TYPE_PROVIDE], 'replace' => ['description' => 'replaces', 'method' => Link::TYPE_REPLACE], 'require-dev' => ['description' => 'requires (for development)', 'method' => Link::TYPE_DEV_REQUIRE], ]

HttpDownloader $jobs = [ ]

HttpDownloader $options = [ ]

HttpDownloader $runningJobs = 0

GitDownloader $gitUtil

ArrayRepository $packageMap = null

FilesystemRepository $file

Git $filesystem

Pool $unacceptableFixedOrLockedPackages

Perforce $commandResult

ComposerRepository $url

ComposerRepository $io

ComposerRepository $httpDownloader

RepositoryManager $localRepository

RepositoryManager $repositoryClasses = [ ]

RepositoryManager $io

RepositoryManager $config

RepositoryManager $httpDownloader

RepositoryManager $eventDispatcher

RepositoryManager $process

VcsDriver $repoConfig

VcsDriver $httpDownloader

VcsDriver $cache

GitLabDriver $project = null

PreFileDownloadEvent $httpDownloader

PreFileDownloadEvent $customCacheKey

PreFileDownloadEvent $type

PreFileDownloadEvent $context

PreFileDownloadEvent $transportOptions = [ ]

ArchiveDownloader $cleanupExecuted = [ ]

RuleSet $ruleById = [ ]

RuleSet $nextRuleId = 0

BaseDependencyCommand $colors

BinaryInstaller $binCompat

BinaryInstaller $vendorDir

ProjectInstaller $filesystem

VersionGuesser $config

RequireCommand $json

InstalledVersions $installed

PlatformRepository $overrides = [ ]

PlatformRepository $disabledPackages = [ ]

Solver $policy

Solver $watchGraph

Solver $propagateIndex

Solver $branches = [ ]

Solver $learnedPool = [ ]

Solver $io

ProcessExecutor $io

ProcessExecutor $runningJobs = 0

ProcessExecutor $maxJobs = 10

Config $repositories

RepositorySet $rootAliases

RepositorySet $temporaryConstraints

RepositorySet $locked = false

RepositorySet $allowInstalledRepositories = false

Svn $cacheCredentials = true

Svn $process

Svn $config

PrePoolCreateEvent $repositories

PrePoolCreateEvent $request

PrePoolCreateEvent $acceptableStabilities

PrePoolCreateEvent $stabilityFlags

PrePoolCreateEvent $rootAliases

PrePoolCreateEvent $rootReferences

FileDownloader $httpDownloader

FileDownloader $cache

FileDownloader $downloadMetadata = [ ]

FileDownloader $lastCacheWrites = [ ]

FileDownloader $additionalCleanupPaths = [ ]

BaseCommand $composer

ValidatingArrayLoader $loader

ValidatingArrayLoader $versionParser

ValidatingArrayLoader $flags

ComposerRepository $baseUrl

Installer $package

Installer $locker

VcsRepository $packageName

VcsRepository $versionParser

VcsRepository $loader

VcsRepository $repoConfig

VcsRepository $drivers

SvnDriver $trunkPath = 'trunk'

PerforceDriver $branch

RemoteFilesystem $retry = false

RemoteFilesystem $progress

DownloadManager $io

DownloadManager $preferSource

DownloadManager $downloaders = [ ]

LibraryInstaller $vendorDir

GitLabDriver $namespace

GitLabDriver $repository

Composer $locker

Composer $downloadManager

Composer $pluginManager

Composer $autoloadGenerator

Composer $archiveManager

CurlDownloader $shareHandle

CurlDownloader $proxyManager

CurlDownloader $supportsSecureProxy

CurlDownloader $timeInfo = ['total_time' => true, 'namelookup_time' => true, 'connect_time' => true, 'pretransfer_time' => true, 'starttransfer_time' => true, 'redirect_time' => true, ]

CreateProjectCommand $suggestedPackagesReporter

HttpDownloader $maxJobs = 12

VcsDownloader $filesystem

GitDownloader $hasStashedChanges = [ ]

GitDownloader $hasDiscardedChanges = [ ]

GitDownloader $cachedPackages = [ ]

PluginManager $runningInGlobalDir = false

ClassLoader $prefixDirsPsr4 = array( )

ClassLoader $fallbackDirsPsr4 = array( )

ClassLoader $prefixesPsr0 = array( )

ClassLoader $fallbackDirsPsr0 = array( )

InstallationManager $installers = [ ]

InstallationManager $loop

InstallationManager $io

Cache $cacheCollected = null

Cache $enabled = null

PartialComposer $package

PartialComposer $loop

PartialComposer $repositoryManager

PartialComposer $installationManager

PartialComposer $config

PartialComposer $eventDispatcher

ComposerRepository $hasAvailablePackageList = false

FossilDriver $repoFile = null

ZipDownloader $isWindows

ZipDownloader $zipArchiveObject

JsonFile $httpDownloader

JsonFile $io

JsonFile $indent = self::INDENT_DEFAULT

PoolOptimizer $policy

PoolBuilder $temporaryConstraints

PoolBuilder $eventDispatcher

PoolBuilder $poolOptimizer

PoolBuilder $restrictedPackagesList = null

PoolBuilder $indexCounter = 0

AutoloadGenerator $io

AutoloadGenerator $platformRequirementFilter

PackageDiscoveryTrait $repos

ConfigCommand $configFile

ConfigCommand $authConfigFile

ConfigCommand $authConfigSource

Locker $contentHash

Locker $loader

RootPackage $minimumStability = 'stable'

RootPackage $preferStable = false

RootPackage $stabilityFlags = [ ]

RootPackage $config = [ ]

RootPackage $references = [ ]

RootPackage $aliases = [ ]

BasePackage $id

ProcessExecutor $jobs = [ ]

FilterRepository $only = null

FilterRepository $exclude = null

FilterRepository $canonical = true

FilesystemRepository $dumpVersions

FilesystemRepository $rootPackage

FilesystemRepository $devMode = null

Git $config

Pool $packageByName = [ ]

Pool $removedVersions = [ ]

Pool $removedVersionsByPackage = [ ]

Application $disablePluginsByDefault = false

Application $disableScriptsByDefault = false

Config $sourceOfConfigValue = [ ]

GitBitbucketDriver $cloneHttpsUrl = ''

GitBitbucketDriver $vcsType

Request $lockedRepository

Request $updateAllowTransitiveDependencies = false

Installer $platformRequirementFilter

GitLabDriver $scheme

GitLabDriver $isPrivate = true

InstalledVersions $installedByVendor = array( )

PlatformRepository $lastSeenPlatformPhp = null

PlatformRepository $runtime

PlatformRepository $hhvmDetector

NoProxyPattern $hostNames = [ ]

NoProxyPattern $noproxy

EventDispatcher $process

EventDispatcher $listeners = [ ]

EventDispatcher $eventStack

Solver $fixedMap

Solver $learnedWhy = [ ]

DefaultPolicy $preferredPackageResultCachePerPool

DefaultPolicy $sortingCachePerPool

Problem $section = 0

ComposerRepository $versionParser

RepositorySet $rootReferences

RepositorySet $rootRequires

FileDownloader $eventDispatcher

FileDownloader $process

FileDownloader $responseHeaders = [ ]

GitHubDriver $isPrivate = false

PluginManager $disablePlugins = false

PluginManager $plugins = [ ]

PluginManager $registeredPlugins = [ ]

ClassLoader $vendorDir

ClassLoader $prefixLengthsPsr4 = array( )

ClassLoader $useIncludePath = false

ClassLoader $classMap = array( )

ClassLoader $classMapAuthoritative = false

ClassLoader $apcuPrefix

ClassLoader $registeredLoaders = array( )

RequireCommand $dependencyResolutionCompleted = false

InstallationManager $cache = [ ]

InstallationManager $notifiablePackages = [ ]

Installer $io

Installer $config

VcsRepository $isVerbose

VcsRepository $isVeryVerbose

VcsRepository $config

VcsRepository $type

VcsRepository $httpDownloader

VcsRepository $processExecutor

VcsRepository $branchErrorOccurred = false

VcsRepository $versionCache

VcsRepository $emptyReferences = [ ]

VcsRepository $versionTransportExceptions = [ ]

SvnDriver $rootIdentifier

SvnDriver $branchesPath = 'branches'

SvnDriver $tagsPath = 'tags'

SvnDriver $packagePath = ''

SvnDriver $cacheCredentials = true

Perforce $p4Depot

Perforce $process

RemoteFilesystem $config

RemoteFilesystem $scheme

RemoteFilesystem $bytesMax

RemoteFilesystem $originUrl

RemoteFilesystem $fileName

RemoteFilesystem $lastProgress

RemoteFilesystem $disableTls = false

RemoteFilesystem $lastHeaders

RemoteFilesystem $storeAuth = false

RemoteFilesystem $degradedMode = false

RemoteFilesystem $redirects

RemoteFilesystem $proxyManager

DownloadManager $preferDist = false

DownloadManager $packagePreferences = [ ]

DownloadManager $filesystem

AutoloadGenerator $devMode = null

AutoloadGenerator $classMapAuthoritative = false

LibraryInstaller $downloadManager

LibraryInstaller $type

BasePackage $repository = null

CompletePackage $abandoned = false

HttpDownloader $io

HttpDownloader $config

HttpDownloader $rfs

HttpDownloader $disabled

HttpDownloader $allowAsync = false

VcsDownloader $config

VcsDownloader $process

VcsDownloader $hasCleanedChanges = [ ]

Application $initialWorkingDirectory

ComposerRepository $providersUrl = null

ComposerRepository $listUrl = null

ComposerRepository $availablePackages = null

ComposerRepository $eventDispatcher

VcsDriver $url

VcsDriver $originUrl

VcsDriver $io

VcsDriver $config

VcsDriver $process

VcsDriver $infoCache = [ ]

Rule $reasonData

RuleSet $rulesByHash = [ ]

Locker $installationManager

Locker $hash

Locker $dumper

Locker $process

Locker $lockDataCache = null

Locker $virtualFileWritten = false

ProcessExecutor $timeout = 300

ProcessExecutor $captureOutput = false

ProcessExecutor $errorOutput = ''

ProcessExecutor $allowAsync = false

Config $baseDir

Config $configSource

Config $authConfigSource

Config $localAuthConfigSource = null

Config $useEnvironment

HgDriver $tags

HgDriver $branches

HgDriver $rootIdentifier

GitBitbucketDriver $hasIssues = false

GitBitbucketDriver $branchesUrl = ''

GitBitbucketDriver $tagsUrl = ''

GitBitbucketDriver $homeUrl = ''

GitBitbucketDriver $website = ''

GitBitbucketDriver $repoData

GitDriver $tags

GitDriver $branches

GitDriver $rootIdentifier

Perforce $path

Perforce $p4User

Perforce $p4Branch

Perforce $windowsFlag

Request $requires = [ ]

Request $fixedLockedPackages = [ ]

Request $updateAllowList = [ ]

Request $restrictedPackages = null

RuleSetGenerator $policy

BaseCommand $io

RunScriptCommand $scriptEvents = [ScriptEvents::PRE_INSTALL_CMD, ScriptEvents::POST_INSTALL_CMD, ScriptEvents::PRE_UPDATE_CMD, ScriptEvents::POST_UPDATE_CMD, ScriptEvents::PRE_STATUS_CMD, ScriptEvents::POST_STATUS_CMD, ScriptEvents::POST_ROOT_PACKAGE_INSTALL, ScriptEvents::POST_CREATE_PROJECT_CMD, ScriptEvents::PRE_ARCHIVE_CMD, ScriptEvents::POST_ARCHIVE_CMD, ScriptEvents::PRE_AUTOLOAD_DUMP, ScriptEvents::POST_AUTOLOAD_DUMP, ]

EventDispatcher $runScripts = true

DiagnoseCommand $process

DiagnoseCommand $exitCode = 0

CurlDownloader $selectTimeout = 5.0

CurlDownloader $maxRedirects = 20

CurlDownloader $maxRetries = 3

CurlDownloader $multiErrors = [CURLM_BAD_HANDLE => ['CURLM_BAD_HANDLE', 'The passed-in handle is not a valid CURLM handle.'], CURLM_BAD_EASY_HANDLE => ['CURLM_BAD_EASY_HANDLE', "An easy handle was not good/valid. It could mean that it isn't an easy handle at all, or possibly that the handle already is in used by this or another multi handle."], CURLM_OUT_OF_MEMORY => ['CURLM_OUT_OF_MEMORY', 'You are doomed.'], CURLM_INTERNAL_ERROR => ['CURLM_INTERNAL_ERROR', 'This can only be returned if libcurl bugs. Please report it to us!'], ]

CurlDownloader $options = ['http' => ['method' => CURLOPT_CUSTOMREQUEST, 'content' => CURLOPT_POSTFIELDS, 'header' => CURLOPT_HTTPHEADER, 'timeout' => CURLOPT_TIMEOUT, ], 'ssl' => ['cafile' => CURLOPT_CAINFO, 'capath' => CURLOPT_CAPATH, 'verify_peer' => CURLOPT_SSL_VERIFYPEER, 'verify_peer_name' => CURLOPT_SSL_VERIFYHOST, 'local_cert' => CURLOPT_SSLCERT, 'local_pk' => CURLOPT_SSLKEY, 'passphrase' => CURLOPT_SSLKEYPASSWD, ], ]

ConsoleIO $lastMessage = ''

ConsoleIO $lastMessageErr = ''

ConsoleIO $startTime

ConsoleIO $verbosityMap

GitHubDriver $rootIdentifier

GitHubDriver $repoData

GitHubDriver $hasIssues = false

GitHubDriver $isArchived = false

PluginManager $versionParser

PluginManager $allowPluginRules

PluginManager $allowGlobalPluginRules

ClassLoader $includeFile

RequireCommand $newlyCreated

RequireCommand $firstRequire

RequireCommand $file

RequireCommand $composerBackup

RequireCommand $lock

RequireCommand $lockBackup

InstallationManager $eventDispatcher

InstallationManager $outputProgress

Installer $fixedRootPackage

Installer $installationManager

Installer $eventDispatcher

Installer $devMode = false

Installer $writeLock

Installer $executeOperations = true

Installer $updateMirrors = false

Installer $updateAllowList = null

Installer $suggestedPackagesReporter

ComposerRepository $loop

ComposerRepository $availablePackagePatterns = null

ComposerRepository $providerListing

ComposerRepository $loader

ComposerRepository $allowSslDowngrade = false

ComposerRepository $degradedMode = false

ComposerRepository $securityAdvisoryConfig = null

ComposerRepository $packagesNotFoundCache = [ ]

FossilDriver $tags

FossilDriver $branches

FossilDriver $rootIdentifier = null

Decisions $pool

PoolBuilder $unacceptableFixedOrLockedPackages = [ ]

PoolBuilder $updateAllowWarned = [ ]

AutoloadGenerator $eventDispatcher

AutoloadGenerator $apcu = false

AutoloadGenerator $apcuPrefix

AutoloadGenerator $dryRun = false

AutoloadGenerator $runScripts = false

PackageDiscoveryTrait $repositorySets

BasePackage $name

BasePackage $prettyName

CompletePackage $repositories = [ ]

CompletePackage $license = [ ]

CompletePackage $keywords = [ ]

CompletePackage $authors = [ ]

CompletePackage $description = null

CompletePackage $homepage = null

CompletePackage $scripts = [ ]

CompletePackage $support = [ ]

CompletePackage $funding = [ ]

CompletePackage $archiveName = null

CompletePackage $archiveExcludes = [ ]

ShowCommand $colors

Git $version = false

Pool $versionParser

Pool $providerCache = [ ]

Application $composer

Application $signalHandler

Perforce $p4Stream

Perforce $p4DepotType

Perforce $io

GitLabDriver $commits = [ ]

GitLabDriver $protocol

GitLabDriver $hasNonstandardOrigin = false

InstalledVersions $canGetVendors

NoProxyPattern $rules = [ ]

Platform $isVirtualBoxGuest = null

Platform $isWindowsSubsystemForLinux = null

Solver $testFlagLearnedPositiveLiteral = false

Problem $reasonSeen

Svn $qtyAuthTries = 0

Svn $version

Installer $repositoryManager

Installer $dryRun = false

Installer $downloadOnly = false

Installer $verbose = false

Installer $runScripts = true

Installer $preferStable = false

Installer $preferLowest = false

Installer $additionalFixedRepository

AliasPackage $version

AliasPackage $prettyVersion

AliasPackage $rootPackageAlias = false

VcsRepository $driver

SvnDriver $tags

SvnDriver $branches

SvnDriver $util

RemoteFilesystem $maxRedirects = 20

LibraryInstaller $composer

LibraryInstaller $io

Package $version

Package $prettyVersion

HttpDownloader $idGen = 0

Filesystem $processExecutor

ComposerRepository $repoConfig

ComposerRepository $notifyUrl = null

ComposerRepository $searchUrl = null

ComposerRepository $providersApiUrl = null

ComposerRepository $hasProviders = false

ComposerRepository $sourceMirrors

ComposerRepository $distMirrors

ComposerRepository $rootData

ComposerRepository $hasPartialPackages = false

ComposerRepository $displayedWarningAboutNonMatchingPackageIndex = false

ComposerRepository $freshMetadataUrls = [ ]

ProcessExecutor $idGen = 0

ShowCommand $versionParser

Config $defaultConfig = ['process-timeout' => 300, 'use-include-path' => false, 'allow-plugins' => [ ], 'use-parent-dir' => 'prompt', 'preferred-install' => 'dist', 'audit' => ['ignore' => [ ], 'abandoned' => Auditor::ABANDONED_FAIL], 'notify-on-install' => true, 'github-protocols' => ['https', 'ssh', 'git'], 'gitlab-protocol' => null, 'vendor-dir' => 'vendor', 'bin-dir' => '{$vendor-dir}/bin', 'cache-dir' => '{$home}/cache', 'data-dir' => '{$home}', 'cache-files-dir' => '{$cache-dir}/files', 'cache-repo-dir' => '{$cache-dir}/repo', 'cache-vcs-dir' => '{$cache-dir}/vcs', 'cache-ttl' => 15552000, 'cache-files-ttl' => null, 'cache-files-maxsize' => '300MiB', 'cache-read-only' => false, 'bin-compat' => 'auto', 'discard-changes' => false, 'autoloader-suffix' => null, 'sort-packages' => false, 'optimize-autoloader' => false, 'classmap-authoritative' => false, 'apcu-autoloader' => false, 'prepend-autoloader' => true, 'github-domains' => ['github.com'], 'bitbucket-expose-hostname' => true, 'disable-tls' => false, 'secure-http' => true, 'secure-svn-domains' => [ ], 'cafile' => null, 'capath' => null, 'github-expose-hostname' => true, 'gitlab-domains' => ['gitlab.com'], 'store-auths' => 'prompt', 'platform' => [ ], 'archive-format' => 'tar', 'archive-dir' => '.', 'htaccess-protect' => true, 'use-github-api' => true, 'lock' => true, 'platform-check' => 'php-only', 'bitbucket-oauth' => [ ], 'github-oauth' => [ ], 'gitlab-oauth' => [ ], 'gitlab-token' => [ ], 'http-basic' => [ ], 'bearer' => [ ], ]

Config $defaultRepositories = ['packagist.org' => ['type' => 'composer', 'url' => 'https://repo.packagist.org', ], ]

Config $warnedHosts = [ ]

Config $sslVerifyWarnedHosts = [ ]

GitBitbucketDriver $rootIdentifier

GitBitbucketDriver $tags

GitBitbucketDriver $branches

Perforce $p4Password

Perforce $p4Port

Perforce $uniquePerforceClientName

Perforce $filesystem

EventDispatcher $loader

InitCommand $gitConfig

Package $sourceType

Package $sourceUrl

Package $sourceReference

Package $sourceMirrors

Package $distType

Package $distUrl

Package $distReference

Package $distMirrors

Package $dev

Package $stability

GitHubDriver $tags

GitHubDriver $branches

GitHubDriver $fundingInfo

PluginManager $classCounter = 0

ClassLoader $missingClasses = array( )

Installer $downloadManager

Installer $autoloadGenerator

Installer $preferSource = false

Installer $preferDist = false

Installer $optimizeAutoloader = false

Installer $classMapAuthoritative = false

Installer $apcuAutoloader = false

Installer $apcuAutoloaderPrefix = null

Installer $update = false

Installer $install = true

Installer $dumpAutoloader = true

Installer $minimalUpdate = false

Installer $audit = true

Installer $errorOnAudit = false

Installer $auditFormat = Auditor::FORMAT_SUMMARY

Installer $updateAllowTransitiveDependencies = Request::UPDATE_ONLY_LISTED

Installer $temporaryConstraints = [ ]

AliasPackage $dev

AliasPackage $stability

AliasPackage $hasSelfVersionRequires = false

Application $logo = ' ______ / ____/___ ____ ___ ____ ____ ________ _____ / / / __ \/ __ `__ \/ __ \/ __ \/ ___/ _ \/ ___/ / /___/ /_/ / / / / / / /_/ / /_/ (__ ) __/ / \____/\____/_/ /_/ /_/ .___/\____/____/\___/_/ /_/ '

Application $hasPluginCommands = false

GitLabDriver $tags

GitLabDriver $branches

Package $type

Package $targetDir

Package $installationSource

Package $distSha1Checksum

Package $releaseDate

Package $extra = [ ]

Package $binaries = [ ]

Package $notificationUrl

Package $requires = [ ]

Package $conflicts = [ ]

Package $provides = [ ]

Package $replaces = [ ]

Package $devRequires = [ ]

Package $suggests = [ ]

Package $autoload = [ ]

Package $devAutoload = [ ]

Package $includePaths = [ ]

Package $isDefaultBranch = false

Package $transportOptions = [ ]

ShowCommand $repositorySet

Perforce $p4Client

AliasPackage $requires

AliasPackage $devRequires

AliasPackage $conflicts

AliasPackage $provides

AliasPackage $replaces

Perforce $p4ClientSpec

Versions $channels = self::CHANNELS

Rule $request