MainConfigSchema.php

Go to the documentation of this file.

<?php
// phpcs:disable Generic.NamingConventions.UpperCaseConstantName.ClassConstantNotUpperCase
// phpcs:disable Generic.Files.LineLength.TooLong
namespace MediaWiki;
 
use AbstractPbkdf2Password;
use ActivityUpdateJob;
use APCUBagOStuff;
use Argon2Password;
use AssembleUploadChunksJob;
use BcryptPassword;
use BlockLogFormatter;
use CategoryMembershipChangeJob;
use CdnPurgeJob;
use ClearUserWatchlistJob;
use ClearWatchlistNotificationsJob;
use ContentModelLogFormatter;
use CssContentHandler;
use DateTime;
use DateTimeZone;
use DeleteLinksJob;
use DeleteLogFormatter;
use DeletePageJob;
use DoubleRedirectJob;
use EmaillingJob;
use EmptyBagOStuff;
use EnotifNotifyJob;
use FallbackContentHandler;
use Generator;
use HashBagOStuff;
use HTMLCacheUpdateJob;
use ImportLogFormatter;
use InvalidArgumentException;
use JavaScriptContentHandler;
use JobQueueDB;
use JsonContentHandler;
use LayeredParameterizedPassword;
use LocalisationCache;
use LocalRepo;
use LogFormatter;
use MediaWiki\Deferred\SiteStatsUpdate;
use MediaWiki\Request\WebRequest;
use MediaWiki\Settings\Source\JsonSchemaTrait;
use MediaWiki\Title\NamespaceInfo;
use MediaWiki\User\CentralId\LocalIdLookup;
use MediaWiki\User\Registration\LocalUserRegistrationProvider;
use MediaWikiSite;
use MemcachedPeclBagOStuff;
use MemcachedPhpBagOStuff;
use MergeLogFormatter;
use MoveLogFormatter;
use MWOldPassword;
use MWSaltedPassword;
use NullJob;
use ParsoidCachePrewarmJob;
use PatrolLogFormatter;
use ProtectLogFormatter;
use PublishStashedFileJob;
use RecentChangesUpdateJob;
use RedisPubSubFeedEngine;
use ReflectionClass;
use RefreshLinksJob;
use RenameUserJob;
use RenameuserLogFormatter;
use ReplicatedBagOStuff;
use RevertedTagUpdateJob;
use RightsLogFormatter;
use SqlBagOStuff;
use TagLogFormatter;
use TextContentHandler;
use ThumbnailRenderJob;
use UDPRCFeedEngine;
use UploadLogFormatter;
use UserEditCountInitJob;
use UserGroupExpiryJob;
use UserOptionsUpdateJob;
use WatchlistExpiryJob;
use Wikimedia\EventRelayer\EventRelayerNull;
use WikitextContentHandler;
use WinCacheBagOStuff;
 
class MainConfigSchema {
    use JsonSchemaTrait;
 
    public static function listDefaultValues( string $prefix = '' ): Generator {
        $class = new ReflectionClass( self::class );
        foreach ( $class->getReflectionConstants() as $const ) {
            if ( !$const->isPublic() ) {
                continue;
            }
 
            $value = $const->getValue();
 
            if ( !is_array( $value ) ) {
                // Just in case we end up having some other kind of constant on this class.
                continue;
            }
 
            if ( isset( $value['obsolete'] ) ) {
                continue;
            }
 
            $name = $const->getName();
            yield "$prefix$name" => self::getDefaultFromJsonSchema( $value );
        }
    }
 
    public static function getDefaultValue( string $name ) {
        $class = new ReflectionClass( self::class );
        if ( !$class->hasConstant( $name ) ) {
            throw new InvalidArgumentException( "Unknown setting: $name" );
        }
        $value = $class->getConstant( $name );
 
        if ( !is_array( $value ) ) {
            // Might happen if we end up having other kinds of constants on this class.
            throw new InvalidArgumentException( "Unknown setting: $name" );
        }
 
        return self::getDefaultFromJsonSchema( $value );
    }
 
    /***************************************************************************/
    public const ConfigRegistry = [
        'default' => [
            'main' => 'GlobalVarConfig::newInstance',
        ],
        'type' => 'map',
    ];
 
    public const Sitename = [
        'default' => 'MediaWiki',
    ];
 
    /***************************************************************************/
    // region   Server URLs and file paths
    public const Server = [
        'default' => false,
    ];
 
    public const CanonicalServer = [
        'default' => false,
    ];
 
    public const ServerName = [
        'default' => false,
    ];
 
    public const AssumeProxiesUseDefaultProtocolPorts = [
        'default' => true,
        'type' => 'boolean',
    ];
 
    public const HttpsPort = [
        'default' => 443,
    ];
 
    public const ForceHTTPS = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const ScriptPath = [
        'default' => '/wiki',
    ];
 
    public const UsePathInfo = [
        'dynamicDefault' => true,
    ];
 
    public static function getDefaultUsePathInfo(): bool {
        // These often break when PHP is set up in CGI mode.
        // PATH_INFO *may* be correct if cgi.fix_pathinfo is set, but then again it may not;
        // lighttpd converts incoming path data to lowercase on systems
        // with case-insensitive filesystems, and there have been reports of
        // problems on Apache as well.
        return !str_contains( PHP_SAPI, 'cgi' ) && !str_contains( PHP_SAPI, 'apache2filter' ) &&
            !str_contains( PHP_SAPI, 'isapi' );
    }
 
    public const Script = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'ScriptPath' ] ]
    ];
 
    public static function getDefaultScript( $scriptPath ): string {
        return "$scriptPath/index.php";
    }
 
    public const LoadScript = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'ScriptPath' ] ]
    ];
 
    public static function getDefaultLoadScript( $scriptPath ): string {
        return "$scriptPath/load.php";
    }
 
    public const RestPath = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'ScriptPath' ] ]
    ];
 
    public static function getDefaultRestPath( $scriptPath ): string {
        return "$scriptPath/rest.php";
    }
 
    public const StylePath = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'ResourceBasePath' ] ]
    ];
 
    public static function getDefaultStylePath( $resourceBasePath ): string {
        return "$resourceBasePath/skins";
    }
 
    public const LocalStylePath = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'ScriptPath' ] ]
    ];
 
    public static function getDefaultLocalStylePath( $scriptPath ): string {
        // Avoid ResourceBasePath here since that may point to a different domain (e.g. CDN)
        return "$scriptPath/skins";
    }
 
    public const ExtensionAssetsPath = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'ResourceBasePath' ] ]
    ];
 
    public static function getDefaultExtensionAssetsPath( $resourceBasePath ): string {
        return "$resourceBasePath/extensions";
    }
 
    public const ExtensionDirectory = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const StyleDirectory = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const BaseDirectory = [
        'default' => null,
    ];
 
    public const ArticlePath = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'Script', 'UsePathInfo' ] ]
    ];
 
    public static function getDefaultArticlePath( string $script, $usePathInfo ): string {
        if ( $usePathInfo ) {
            return "$script/$1";
        }
        return "$script?title=$1";
    }
 
    public const UploadPath = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'ScriptPath' ] ]
    ];
 
    public static function getDefaultUploadPath( $scriptPath ): string {
        return "$scriptPath/images";
    }
 
    public const ImgAuthPath = [
        'default' => false,
    ];
 
    public const ThumbPath = [
        'default' => false,
    ];
 
    public const UploadDirectory = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'BaseDirectory' ] ]
    ];
 
    public static function getDefaultUploadDirectory( $baseDirectory ): string {
        return "$baseDirectory/images";
    }
 
    public const FileCacheDirectory = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'UploadDirectory' ] ]
    ];
 
    public static function getDefaultFileCacheDirectory( $uploadDirectory ): string {
        return "$uploadDirectory/cache";
    }
 
    public const Logo = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'ResourceBasePath' ] ]
    ];
 
    public static function getDefaultLogo( $resourceBasePath ): string {
        return "$resourceBasePath/resources/assets/change-your-logo.svg";
    }
 
    public const Logos = [
        'default' => false,
        'type' => 'map|false',
    ];
 
    public const LogoHD = [
        'default' => false,
        'type' => 'map|false',
        'deprecated' => 'since 1.35. Developers should retrieve this logo (and other variants) ' .
            'using the static function MediaWiki\ResourceLoader\SkinModule::getAvailableLogos. $wgLogos ' .
            'should be used instead.',
    ];
 
    public const Favicon = [
        'default' => '/favicon.ico',
    ];
 
    public const AppleTouchIcon = [
        'default' => false,
    ];
 
    public const ReferrerPolicy = [
        'default' => false,
        'type' => 'list|string|false',
    ];
 
    public const TmpDirectory = [
        'default' => false,
    ];
 
    public const UploadBaseUrl = [
        'default' => '',
    ];
 
    public const UploadStashScalerBaseUrl = [
        'default' => false,
        'deprecated' => 'since 1.36 Use thumbProxyUrl in $wgLocalFileRepo',
    ];
 
    public const ActionPaths = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const MainPageIsDomainRoot = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    // endregion -- end of server URLs and file paths
 
    /***************************************************************************/
    // region   Files and file uploads
    public const EnableUploads = [
        'default' => false,
    ];
 
    public const UploadStashMaxAge = [
        'default' => 6 * 3600, // 6 hours
    ];
 
    public const EnableAsyncUploads = [
        'default' => false,
    ];
 
    public const UploadMaintenance = [
        'default' => false,
    ];
 
    public const IllegalFileChars = [
        'default' => ':\\/\\\\',
        'deprecated' => 'since 1.41; no longer customizable',
    ];
 
    public const DeletedDirectory = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'UploadDirectory' ] ]
    ];
 
    public static function getDefaultDeletedDirectory( $uploadDirectory ): string {
        return "$uploadDirectory/deleted";
    }
 
    public const ImgAuthDetails = [
        'default' => false,
    ];
 
    public const ImgAuthUrlPathMap = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const LocalFileRepo = [
        'default' => false,
        'type' => 'map|false',
        'dynamicDefault' => [ 'use' => [ 'UploadDirectory', 'ScriptPath', 'Favicon', 'UploadBaseUrl',
            'UploadPath', 'HashedUploadDirectory', 'ThumbnailScriptPath',
            'GenerateThumbnailOnParse', 'DeletedDirectory', 'UpdateCompatibleMetadata' ] ],
    ];
 
    public static function getDefaultLocalFileRepo(
        $uploadDirectory, $scriptPath, $favicon, $uploadBaseUrl, $uploadPath,
        $hashedUploadDirectory, $thumbnailScriptPath, $generateThumbnailOnParse, $deletedDirectory,
        $updateCompatibleMetadata
    ) {
        return [
            'class' => LocalRepo::class,
            'name' => 'local',
            'directory' => $uploadDirectory,
            'scriptDirUrl' => $scriptPath,
            'favicon' => $favicon,
            'url' => $uploadBaseUrl ? $uploadBaseUrl . $uploadPath : $uploadPath,
            'hashLevels' => $hashedUploadDirectory ? 2 : 0,
            'thumbScriptUrl' => $thumbnailScriptPath,
            'transformVia404' => !$generateThumbnailOnParse,
            'deletedDir' => $deletedDirectory,
            'deletedHashLevels' => $hashedUploadDirectory ? 3 : 0,
            'updateCompatibleMetadata' => $updateCompatibleMetadata,
            'reserializeMetadata' => $updateCompatibleMetadata,
        ];
    }
 
    public const ForeignFileRepos = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const UseInstantCommons = [
        'default' => false,
    ];
 
    public const UseSharedUploads = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const SharedUploadDirectory = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const SharedUploadPath = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const HashedSharedUploadDirectory = [
        'default' => true,
        'type' => 'boolean',
    ];
 
    public const RepositoryBaseUrl = [
        'default' => 'https://commons.wikimedia.org/wiki/File:',
    ];
 
    public const FetchCommonsDescriptions = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const SharedUploadDBname = [
        'default' => false,
        'type' => 'false|string',
    ];
 
    public const SharedUploadDBprefix = [
        'default' => '',
        'type' => 'string',
    ];
 
    public const CacheSharedUploads = [
        'default' => true,
        'type' => 'boolean',
    ];
 
    public const ForeignUploadTargets = [
        'default' => [ 'local', ],
        'type' => 'list',
    ];
 
    public const UploadDialog = [
        'default' =>
            [
                'fields' =>
                    [
                        'description' => true,
                        'date' => false,
                        'categories' => false,
                    ],
                'licensemessages' =>
                    [
                        'local' => 'generic-local',
                        'foreign' => 'generic-foreign',
                    ],
                'comment' =>
                    [
                        'local' => '',
                        'foreign' => '',
                    ],
                'format' =>
                    [
                        'filepage' => '$DESCRIPTION',
                        'description' => '$TEXT',
                        'ownwork' => '',
                        'license' => '',
                        'uncategorized' => '',
                    ],
            ],
        'type' => 'map',
    ];
 
    public const FileBackends = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const LockManagers = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const ShowEXIF = [
        'dynamicDefault' => [ 'callback' => [ self::class, 'getDefaultShowEXIF' ] ],
    ];
 
    public static function getDefaultShowEXIF(): bool {
        return function_exists( 'exif_read_data' );
    }
 
    public const UpdateCompatibleMetadata = [
        'default' => false,
    ];
 
    public const AllowCopyUploads = [
        'default' => false,
    ];
 
    public const CopyUploadsDomains = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const CopyUploadsFromSpecialUpload = [
        'default' => false,
    ];
 
    public const CopyUploadProxy = [
        'default' => false,
    ];
 
    public const CopyUploadTimeout = [
        'default' => false,
        'type' => 'false|integer',
    ];
 
    public const CopyUploadAllowOnWikiDomainConfig = [
        'default' => false,
    ];
 
    public const MaxUploadSize = [
        'default' => 1024 * 1024 * 100,
    ];
 
    public const MinUploadChunkSize = [
        'default' => 1024,
    ];
 
    public const UploadNavigationUrl = [
        'default' => false,
    ];
 
    public const UploadMissingFileUrl = [
        'default' => false,
    ];
 
    public const ThumbnailScriptPath = [
        'default' => false,
    ];
 
    public const SharedThumbnailScriptPath = [
        'default' => false,
        'type' => 'string|false',
    ];
 
    public const HashedUploadDirectory = [
        'default' => true,
        'type' => 'boolean',
    ];
 
    public const FileExtensions = [
        'default' => [ 'png', 'gif', 'jpg', 'jpeg', 'webp', ],
        'type' => 'list',
    ];
 
    public const ProhibitedFileExtensions = [
        'default' => [
            # HTML may contain cookie-stealing JavaScript and web bugs
            'html', 'htm', 'js', 'jsb', 'mhtml', 'mht', 'xhtml', 'xht',
            # PHP scripts may execute arbitrary code on the server
            'php', 'phtml', 'php3', 'php4', 'php5', 'phps', 'phar',
            # Other types that may be interpreted by some servers
            'shtml', 'jhtml', 'pl', 'py', 'cgi',
            # May contain harmful executables for Windows victims
            'exe', 'scr', 'dll', 'msi', 'vbs', 'bat', 'com', 'pif', 'cmd', 'vxd', 'cpl',
            # T341565
            'xml',
        ],
        'type' => 'list',
    ];
 
    public const MimeTypeExclusions = [
        'default' => [
            # HTML may contain cookie-stealing JavaScript and web bugs
            'text/html',
            # Similarly with JavaScript itself
            'application/javascript', 'text/javascript', 'text/x-javascript', 'application/x-shellscript',
            # PHP scripts may execute arbitrary code on the server
            'application/x-php', 'text/x-php',
            # Other types that may be interpreted by some servers
            'text/x-python', 'text/x-perl', 'text/x-bash', 'text/x-sh', 'text/x-csh',
            # Client-side hazards on Internet Explorer
            'text/scriptlet', 'application/x-msdownload',
            # Windows metafile, client-side vulnerability on some systems
            'application/x-msmetafile',
            # Files that look like java files
            'application/java',
            # XML files generally - T341565
            'application/xml', 'text/xml',
        ],
        'type' => 'list',
    ];
 
    public const CheckFileExtensions = [
        'default' => true,
    ];
 
    public const StrictFileExtensions = [
        'default' => true,
    ];
 
    public const DisableUploadScriptChecks = [
        'default' => false,
    ];
 
    public const UploadSizeWarning = [
        'default' => false,
    ];
 
    public const TrustedMediaFormats = [
        'default' => [
            MEDIATYPE_BITMAP, // all bitmap formats
            MEDIATYPE_AUDIO, // all audio formats
            MEDIATYPE_VIDEO, // all plain video formats
            "image/svg+xml", // svg (only needed if inline rendering of svg is not supported)
            "application/pdf", // PDF files
            # "application/x-shockwave-flash", //flash/shockwave movie
        ],
        'type' => 'list',
    ];
 
    public const MediaHandlers = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const NativeImageLazyLoading = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const ParserTestMediaHandlers = [
        'default' => [
            'image/jpeg' => 'MockBitmapHandler',
            'image/png' => 'MockBitmapHandler',
            'image/gif' => 'MockBitmapHandler',
            'image/tiff' => 'MockBitmapHandler',
            'image/webp' => 'MockBitmapHandler',
            'image/x-ms-bmp' => 'MockBitmapHandler',
            'image/x-bmp' => 'MockBitmapHandler',
            'image/x-xcf' => 'MockBitmapHandler',
            'image/svg+xml' => 'MockSvgHandler',
            'image/vnd.djvu' => 'MockDjVuHandler',
        ],
        'type' => 'map',
    ];
 
    public const UseImageResize = [
        'default' => true,
    ];
 
    public const UseImageMagick = [
        'default' => false,
    ];
 
    public const ImageMagickConvertCommand = [
        'default' => '/usr/bin/convert',
    ];
 
    public const MaxInterlacingAreas = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const SharpenParameter = [
        'default' => '0x0.4',
    ];
 
    public const SharpenReductionThreshold = [
        'default' => 0.85,
    ];
 
    public const ImageMagickTempDir = [
        'default' => false,
    ];
 
    public const CustomConvertCommand = [
        'default' => false,
    ];
 
    public const JpegTran = [
        'default' => '/usr/bin/jpegtran',
    ];
 
    public const JpegPixelFormat = [
        'default' => 'yuv420',
    ];
 
    public const JpegQuality = [
        'default' => 80,
    ];
 
    public const Exiv2Command = [
        'default' => '/usr/bin/exiv2',
    ];
 
    public const Exiftool = [
        'default' => '/usr/bin/exiftool',
    ];
 
    public const SVGConverters = [
        'default' => [
            'ImageMagick' => '$path/convert -background "#ffffff00" -thumbnail $widthx$height\\! $input PNG:$output',
            'sodipodi' => '$path/sodipodi -z -w $width -f $input -e $output',
            'inkscape' => '$path/inkscape -z -w $width -f $input -e $output',
            'batik' => 'java -Djava.awt.headless=true -jar $path/batik-rasterizer.jar -w $width -d $output $input',
            'rsvg' => '$path/rsvg-convert -w $width -h $height -o $output $input',
            'imgserv' => '$path/imgserv-wrapper -i svg -o png -w$width $input $output',
            'ImagickExt' => [ 'SvgHandler::rasterizeImagickExt', ],
        ],
        'type' => 'map',
    ];
 
    public const SVGConverter = [
        'default' => 'ImageMagick',
    ];
 
    public const SVGConverterPath = [
        'default' => '',
    ];
 
    public const SVGMaxSize = [
        'default' => 5120,
    ];
 
    public const SVGMetadataCutoff = [
        'default' => 262144,
    ];
 
    public const SVGNativeRendering = [
        'default' => false,
        'type' => 'string|boolean',
    ];
 
    public const SVGNativeRenderingSizeLimit = [
        'default' => 50 * 1024,
    ];
 
    public const MediaInTargetLanguage = [
        'default' => true,
    ];
 
    public const MaxImageArea = [
        'default' => 12500000,
        'type' => 'string|integer|false',
    ];
 
    public const MaxAnimatedGifArea = [
        'default' => 12500000,
    ];
 
    public const TiffThumbnailType = [
        'default' => [],
        'type' => 'list',
        'mergeStrategy' => 'replace',
    ];
 
    public const ThumbnailEpoch = [
        'default' => '20030516000000',
    ];
 
    public const AttemptFailureEpoch = [
        'default' => 1,
    ];
 
    public const IgnoreImageErrors = [
        'default' => false,
    ];
 
    public const GenerateThumbnailOnParse = [
        'default' => true,
        'type' => 'boolean',
    ];
 
    public const ShowArchiveThumbnails = [
        'default' => true,
    ];
 
    public const EnableAutoRotation = [
        'default' => null,
        'type' => '?boolean',
    ];
 
    public const Antivirus = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const AntivirusSetup = [
        'default' => [
            # setup for clamav
            'clamav' => [
                'command' => 'clamscan --no-summary ',
                'codemap' => [
                    "0" => AV_NO_VIRUS, # no virus
                    "1" => AV_VIRUS_FOUND, # virus found
                    "52" => AV_SCAN_ABORTED, # unsupported file format (probably immune)
                    "*" => AV_SCAN_FAILED, # else scan failed
                ],
                'messagepattern' => '/.*?:(.*)/sim',
            ],
        ],
        'type' => 'map',
    ];
 
    public const AntivirusRequired = [
        'default' => true,
    ];
 
    public const VerifyMimeType = [
        'default' => true,
    ];
 
    public const MimeTypeFile = [
        'default' => 'internal',
    ];
 
    public const MimeInfoFile = [
        'default' => 'internal',
    ];
 
    public const MimeDetectorCommand = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const TrivialMimeDetection = [
        'default' => false,
    ];
 
    public const XMLMimeTypes = [
        'default' => [
            'http://www.w3.org/2000/svg:svg' => 'image/svg+xml',
            'svg' => 'image/svg+xml',
            'http://www.lysator.liu.se/~alla/dia/:diagram' => 'application/x-dia-diagram',
            'http://www.w3.org/1999/xhtml:html' => 'text/html',
            'html' => 'text/html',
        ],
        'type' => 'map',
    ];
 
    public const ImageLimits = [
        'default' => [
            [ 320, 240 ],
            [ 640, 480 ],
            [ 800, 600 ],
            [ 1024, 768 ],
            [ 1280, 1024 ],
            [ 2560, 2048 ],
        ],
        'type' => 'list',
    ];
 
    public const ThumbLimits = [
        'default' => [
            120,
            150,
            180,
            200,
            250,
            300
        ],
        'type' => 'list',
    ];
 
    public const ThumbnailNamespaces = [
        'default' => [ NS_FILE ],
        'type' => 'list',
        'items' => [ 'type' => 'integer', ],
    ];
 
    public const ThumbnailBuckets = [
        'default' => null,
        'type' => '?list',
    ];
 
    public const ThumbnailMinimumBucketDistance = [
        'default' => 50,
    ];
 
    public const UploadThumbnailRenderMap = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const UploadThumbnailRenderMethod = [
        'default' => 'jobqueue',
    ];
 
    public const UploadThumbnailRenderHttpCustomHost = [
        'default' => false,
    ];
 
    public const UploadThumbnailRenderHttpCustomDomain = [
        'default' => false,
    ];
 
    public const UseTinyRGBForJPGThumbnails = [
        'default' => false,
    ];
 
    public const GalleryOptions = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ThumbUpright = [
        'default' => 0.75,
    ];
 
    public const DirectoryMode = [
        'default' => 0777, // octal!
    ];
 
    public const ResponsiveImages = [
        'default' => true,
    ];
 
    public const ImagePreconnect = [
        'default' => false,
    ];
 
    /***************************************************************************/
    // region   DJVU settings
    public const DjvuDump = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const DjvuRenderer = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const DjvuTxt = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const DjvuPostProcessor = [
        'default' => 'pnmtojpeg',
        'type' => '?string',
    ];
 
    public const DjvuOutputExtension = [
        'default' => 'jpg',
    ];
 
    // endregion -- end of DJvu
 
    // endregion -- end of file uploads
 
    /***************************************************************************/
    // region   Email settings
    public const EmergencyContact = [
        'default' => false,
    ];
 
    public const PasswordSender = [
        'default' => false,
    ];
 
    public const NoReplyAddress = [
        'default' => false,
    ];
 
    public const EnableEmail = [
        'default' => true,
    ];
 
    public const EnableUserEmail = [
        'default' => true,
    ];
 
    public const EnableSpecialMute = [
        'default' => false,
    ];
 
    public const EnableUserEmailMuteList = [
        'default' => false,
    ];
 
    public const UserEmailUseReplyTo = [
        'default' => true,
    ];
 
    public const PasswordReminderResendTime = [
        'default' => 24,
    ];
 
    public const NewPasswordExpiry = [
        'default' => 3600 * 24 * 7,
    ];
 
    public const UserEmailConfirmationTokenExpiry = [
        'default' => 7 * 24 * 60 * 60,
    ];
 
    public const PasswordExpirationDays = [
        'default' => false,
    ];
 
    public const PasswordExpireGrace = [
        'default' => 3600 * 24 * 7,
    ];
 
    public const SMTP = [
        'default' => false,
        'type' => 'false|map',
    ];
 
    public const AdditionalMailParams = [
        'default' => null,
    ];
 
    public const AllowHTMLEmail = [
        'default' => false,
    ];
 
    public const EnotifFromEditor = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const EmailAuthentication = [
        'default' => true,
    ];
 
    public const EnotifWatchlist = [
        'default' => false,
    ];
 
    public const EnotifUserTalk = [
        'default' => false,
    ];
 
    public const EnotifRevealEditorAddress = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const EnotifMinorEdits = [
        'default' => true,
    ];
 
    public const EnotifImpersonal = [
        'default' => false,
    ];
 
    public const EnotifMaxRecips = [
        'default' => 500,
    ];
 
    public const EnotifUseRealName = [
        'default' => false,
    ];
 
    public const UsersNotifiedOnAllChanges = [
        'default' => [],
        'type' => 'map',
    ];
 
    // endregion -- end of email settings
 
    /***************************************************************************/
    // region  Database settings
    public const DBname = [
        'default' => 'my_wiki',
    ];
 
    public const DBmwschema = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const DBprefix = [
        'default' => '',
    ];
 
    public const DBserver = [
        'default' => 'localhost',
    ];
 
    public const DBport = [
        'default' => 5432,
    ];
 
    public const DBuser = [
        'default' => 'wikiuser',
    ];
 
    public const DBpassword = [
        'default' => '',
    ];
 
    public const DBtype = [
        'default' => 'mysql',
    ];
 
    public const DBssl = [
        'default' => false,
    ];
 
    public const DBcompress = [
        'default' => false,
    ];
 
    public const DBadminuser = [
        'default' => null,
    ];
 
    public const DBadminpassword = [
        'default' => null,
    ];
 
    public const SearchType = [
        'default' => null,
    ];
 
    public const SearchTypeAlternatives = [
        'default' => null,
    ];
 
    public const DBTableOptions = [
        'default' => 'ENGINE=InnoDB, DEFAULT CHARSET=binary',
    ];
 
    public const SQLMode = [
        'default' => '',
    ];
 
    public const DBDefaultGroup = [
        'default' => null,
    ];
 
    public const SQLiteDataDir = [
        'default' => '',
    ];
 
    public const SharedDB = [
        'default' => null,
    ];
 
    public const SharedPrefix = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'DBprefix' ] ]
    ];
 
    public static function getDefaultSharedPrefix( $dbPrefix ) {
        return $dbPrefix;
    }
 
    public const SharedTables = [
        'default' => [
            'user',
            'user_properties',
            'user_autocreate_serial',
        ],
        'type' => 'list',
    ];
 
    public const SharedSchema = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'DBmwschema' ] ]
    ];
 
    public static function getDefaultSharedSchema( $dbMwschema ) {
        return $dbMwschema;
    }
 
    public const DBservers = [
        'default' => false,
        'type' => 'false|list',
    ];
 
    public const LBFactoryConf = [
        'default' => [
            'class' => 'Wikimedia\\Rdbms\\LBFactorySimple',
        ],
        'type' => 'map',
        'mergeStrategy' => 'replace',
    ];
 
    public const DataCenterUpdateStickTTL = [
        'default' => 10,
    ];
 
    public const DBerrorLog = [
        'default' => false,
    ];
 
    public const DBerrorLogTZ = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'Localtimezone' ] ]
    ];
 
    public static function getDefaultDBerrorLogTZ( $localtimezone ) {
        // NOTE: Extra fallback, in case $localtimezone is ''.
        //       Many extsing LocalSettings files have $wgLocaltimezone = ''
        //       in them, erroneously generated by the installer.
        return $localtimezone ?: self::getDefaultLocaltimezone();
    }
 
    public const LocalDatabases = [
        'default' => [],
        'type' => 'list',
        'items' => [ 'type' => 'string', ],
    ];
 
    public const DatabaseReplicaLagWarning = [
        'default' => 10,
    ];
 
    public const DatabaseReplicaLagCritical = [
        'default' => 30,
    ];
 
    public const MaxExecutionTimeForExpensiveQueries = [
        'default' => 0,
    ];
 
    public const VirtualDomainsMapping = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const TemplateLinksSchemaMigrationStage = [
        'default' => SCHEMA_COMPAT_WRITE_NEW | SCHEMA_COMPAT_READ_NEW,
        'type' => 'integer',
    ];
 
    public const PageLinksSchemaMigrationStage = [
        'default' => SCHEMA_COMPAT_WRITE_OLD | SCHEMA_COMPAT_READ_OLD,
        'type' => 'integer',
    ];
 
    public const ExternalLinksDomainGaps = [
        'default' => [],
        'type' => 'map',
    ];
 
    // endregion -- End of DB settings
 
    /***************************************************************************/
    // region   Content handlers and storage
    public const ContentHandlers = [
        'default' =>
            [
                // the usual case
                CONTENT_MODEL_WIKITEXT => [
                    'class' => WikitextContentHandler::class,
                    'services' => [
                        'TitleFactory',
                        'ParserFactory',
                        'GlobalIdGenerator',
                        'LanguageNameUtils',
                        'LinkRenderer',
                        'MagicWordFactory',
                        'ParsoidParserFactory',
                    ],
                ],
                // dumb version, no syntax highlighting
                CONTENT_MODEL_JAVASCRIPT => JavaScriptContentHandler::class,
                // simple implementation, for use by extensions, etc.
                CONTENT_MODEL_JSON => JsonContentHandler::class,
                // dumb version, no syntax highlighting
                CONTENT_MODEL_CSS => CssContentHandler::class,
                // plain text, for use by extensions, etc.
                CONTENT_MODEL_TEXT => TextContentHandler::class,
                // fallback for unknown models, from imports or extensions that were removed
                CONTENT_MODEL_UNKNOWN => FallbackContentHandler::class,
            ],
        'type' => 'map',
    ];
 
    public const NamespaceContentModels = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ContentHandlerTextFallback = [
        'default' => 'ignore',
        'deprecated' => 'since 1.37',
    ];
 
    public const TextModelsToParse = [
        'default' => [
            CONTENT_MODEL_WIKITEXT, // Just for completeness, wikitext will always be parsed.
            CONTENT_MODEL_JAVASCRIPT, // Make categories etc work, people put them into comments.
            CONTENT_MODEL_CSS, // Make categories etc work, people put them into comments.
        ],
        'type' => 'list',
    ];
 
    public const CompressRevisions = [
        'default' => false,
    ];
 
    public const ExternalStores = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const ExternalServers = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const DefaultExternalStore = [
        'default' => false,
        'type' => 'list|false',
    ];
 
    public const RevisionCacheExpiry = [
        'default' => 86400 * 7,
        'type' => 'integer',
    ];
 
    public const PageLanguageUseDB = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const DiffEngine = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const ExternalDiffEngine = [
        'default' => false,
        'type' => 'string|false',
    ];
 
    public const Wikidiff2Options = [
        'default' => [],
        'type' => 'map'
    ];
 
    // endregion -- end of Content handlers and storage
 
    /***************************************************************************/
    // region   Performance hacks and limits
    public const RequestTimeLimit = [
        'default' => null,
        'type' => '?integer',
    ];
 
    public const TransactionalTimeLimit = [
        'default' => 120,
    ];
 
    public const CriticalSectionTimeLimit = [
        'default' => 180.0,
        'type' => 'float',
    ];
 
    public const MiserMode = [
        'default' => false,
    ];
 
    public const DisableQueryPages = [
        'default' => false,
    ];
 
    public const QueryCacheLimit = [
        'default' => 1000,
    ];
 
    public const WantedPagesThreshold = [
        'default' => 1,
    ];
 
    public const AllowSlowParserFunctions = [
        'default' => false,
    ];
 
    public const AllowSchemaUpdates = [
        'default' => true,
    ];
 
    public const MaxArticleSize = [
        'default' => 2048,
    ];
 
    public const MemoryLimit = [
        'default' => '50M',
    ];
 
    public const PoolCounterConf = [
        'default' => null,
        'type' => '?map',
    ];
 
    public const PoolCountClientConf = [
        'default' => [
            'servers' => [
                '127.0.0.1'
            ],
            'timeout' => 0.1,
        ],
        'type' => 'map',
    ];
 
    public const MaxUserDBWriteDuration = [
        'default' => false,
        'type' => 'integer|false',
    ];
 
    public const MaxJobDBWriteDuration = [
        'default' => false,
        'type' => 'integer|false',
    ];
 
    public const LinkHolderBatchSize = [
        'default' => 1000,
    ];
 
    public const MaximumMovedPages = [
        'default' => 100,
    ];
 
    public const ForceDeferredUpdatesPreSend = [
        'default' => false,
    ];
 
    public const MultiShardSiteStats = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    // endregion -- end performance hacks
 
    /***************************************************************************/
    // region   Cache settings
    public const CacheDirectory = [
        'default' => false,
    ];
 
    public const MainCacheType = [
        'default' => CACHE_NONE,
    ];
 
    public const MessageCacheType = [
        'default' => CACHE_ANYTHING,
    ];
 
    public const ParserCacheType = [
        'default' => CACHE_ANYTHING,
    ];
 
    public const SessionCacheType = [
        'default' => CACHE_ANYTHING,
    ];
 
    public const LanguageConverterCacheType = [
        'default' => CACHE_ANYTHING,
    ];
 
    public const ObjectCaches = [
        'default' => [
            CACHE_NONE => [ 'class' => EmptyBagOStuff::class, 'reportDupes' => false ],
            CACHE_DB => [ 'class' => SqlBagOStuff::class, 'loggroup' => 'SQLBagOStuff' ],
 
            CACHE_ANYTHING => [ 'factory' => 'ObjectCache::newAnything' ],
            CACHE_ACCEL => [ 'factory' => 'ObjectCache::getLocalServerInstance' ],
 
            'db-replicated' => [
                'class'        => ReplicatedBagOStuff::class,
                'readFactory'  => [
                    'factory' => 'ObjectCache::newFromParams',
                    'args'    => [ [ 'class' => SqlBagOStuff::class, 'replicaOnly' => true ] ]
                ],
                'writeFactory' => [
                    'factory' => 'ObjectCache::newFromParams',
                    'args'    => [ [ 'class' => SqlBagOStuff::class, 'replicaOnly' => false ] ]
                ],
                'loggroup'     => 'SQLBagOStuff',
                'reportDupes'  => false
            ],
            'memcached-php' => [ 'class' => MemcachedPhpBagOStuff::class, 'loggroup' => 'memcached' ],
            'memcached-pecl' => [ 'class' => MemcachedPeclBagOStuff::class, 'loggroup' => 'memcached' ],
            'hash' => [ 'class' => HashBagOStuff::class, 'reportDupes' => false ],
 
            // Deprecated since 1.35.
            // - To configure a wg*CacheType variable to use the local server cache,
            //   use CACHE_ACCEL instead, which will select these automatically.
            // - To access the object for the local server cache at run-time,
            //   use MediaWikiServices::getLocalServerObjectCache()
            //   instead of e.g. ObjectCache::getInstance( 'apcu' ).
            // - To instantiate a new one of these explicitly, do so directly
            //   by using `new APCUBagOStuff( [ … ] )`
            // - To instantiate a new one of these including auto-detection and fallback,
            //   use ObjectCache::makeLocalServerCache().
            'apc' => [ 'class' => APCUBagOStuff::class, 'reportDupes' => false ],
            'apcu' => [ 'class' => APCUBagOStuff::class, 'reportDupes' => false ],
            'wincache' => [ 'class' => WinCacheBagOStuff::class, 'reportDupes' => false ],
        ],
        'type' => 'map',
    ];
 
    public const WANObjectCache = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const MicroStashType = [
        'default' => CACHE_ANYTHING,
        'type' => 'string|int',
    ];
 
    public const MainStash = [
        'default' => 'db-replicated',
    ];
 
    public const ParsoidCacheConfig = [
        'type' => 'object',
        'properties' => [
            'StashType' => [ 'type' => 'int|string|null', 'default' => null ],
            'StashDuration' => [ 'type' => 'int', 'default' => 24 * 60 * 60 ],
            'CacheThresholdTime' => [ 'type' => 'float', 'default' => 0.0 ],
            'WarmParsoidParserCache' => [ 'type' => 'bool', 'default' => false ],
        ]
    ];
 
    public const ChronologyProtectorStash = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const ChronologyProtectorSecret = [
        'default' => '',
        'type' => 'string',
    ];
 
    public const ParserCacheExpireTime = [
        'default' => 60 * 60 * 24,
    ];
 
    public const OldRevisionParserCacheExpireTime = [
        'default' => 60 * 60,
    ];
 
    public const ObjectCacheSessionExpiry = [
        'default' => 60 * 60,
    ];
 
    public const PHPSessionHandling = [
        'default' => 'enable',
        'type' => 'string',
    ];
 
    public const SuspiciousIpExpiry = [
        'default' => false,
        'type' => 'integer|false',
    ];
 
    public const SessionPbkdf2Iterations = [
        'default' => 10001,
    ];
 
    public const MemCachedServers = [
        'default' => [ '127.0.0.1:11211', ],
        'type' => 'list',
    ];
 
    public const MemCachedPersistent = [
        'default' => false,
    ];
 
    public const MemCachedTimeout = [
        'default' => 500000,
    ];
 
    public const UseLocalMessageCache = [
        'default' => false,
    ];
 
    public const AdaptiveMessageCache = [
        'default' => false,
    ];
 
    public const LocalisationCacheConf = [
        'properties' => [
            'class' => [ 'type' => 'string', 'default' => LocalisationCache::class ],
            'store' => [ 'type' => 'string', 'default' => 'detect' ],
            'storeClass' => [ 'type' => 'false|string', 'default' => false ],
            'storeDirectory' => [ 'type' => 'false|string', 'default' => false ],
            'storeServer' => [ 'type' => 'object', 'default' => [] ],
            'forceRecache' => [ 'type' => 'bool', 'default' => false ],
            'manualRecache' => [ 'type' => 'bool', 'default' => false ],
        ],
        'type' => 'object',
    ];
 
    public const CachePages = [
        'default' => true,
    ];
 
    public const CacheEpoch = [
        'default' => '20030516000000',
    ];
 
    public const GitInfoCacheDirectory = [
        'default' => false,
    ];
 
    public const UseFileCache = [
        'default' => false,
    ];
 
    public const FileCacheDepth = [
        'default' => 2,
    ];
 
    public const RenderHashAppend = [
        'default' => '',
    ];
 
    public const EnableSidebarCache = [
        'default' => false,
    ];
 
    public const SidebarCacheExpiry = [
        'default' => 86400,
    ];
 
    public const UseGzip = [
        'default' => false,
    ];
 
    public const InvalidateCacheOnLocalSettingsChange = [
        'default' => true,
    ];
 
    public const ExtensionInfoMTime = [
        'default' => false,
        'type' => 'integer|false',
    ];
 
    public const EnableRemoteBagOStuffTests = [
        'default' => false,
    ];
 
    // endregion -- end of cache settings
 
    /***************************************************************************/
    // region   HTTP proxy (CDN) settings
    public const UseCdn = [
        'default' => false,
    ];
 
    public const VaryOnXFP = [
        'default' => false,
    ];
 
    public const InternalServer = [
        'default' => false,
    ];
 
    public const CdnMaxAge = [
        'default' => 18000,
    ];
 
    public const CdnMaxageLagged = [
        'default' => 30,
    ];
 
    public const CdnMaxageStale = [
        'default' => 10,
    ];
 
    public const CdnReboundPurgeDelay = [
        'default' => 0,
    ];
 
    public const CdnMaxageSubstitute = [
        'default' => 60,
    ];
 
    public const ForcedRawSMaxage = [
        'default' => 300,
    ];
 
    public const CdnServers = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const CdnServersNoPurge = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const SquidPurgeUseHostHeader = [
        'default' => true,
        'deprecated' => 'since 1.33',
    ];
 
    public const HTCPRouting = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const HTCPMulticastTTL = [
        'default' => 1,
    ];
 
    public const UsePrivateIPs = [
        'default' => false,
    ];
 
    public const CdnMatchParameterOrder = [
        'default' => true,
    ];
 
    // endregion -- end of HTTP proxy settings
 
    /***************************************************************************/
    // region   Language, regional and character encoding settings
    public const LanguageCode = [
        'default' => 'en',
    ];
 
    public const GrammarForms = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const InterwikiMagic = [
        'default' => true,
    ];
 
    public const HideInterlanguageLinks = [
        'default' => false,
    ];
 
    public const ExtraInterlanguageLinkPrefixes = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const InterlanguageLinkCodeMap = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ExtraLanguageNames = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ExtraLanguageCodes = [
        'default' => [
            'bh' => 'bho',
            'no' => 'nb',
            'simple' => 'en',
        ],
        'type' => 'map',
    ];
 
    public const DummyLanguageCodes = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const AllUnicodeFixes = [
        'default' => false,
    ];
 
    public const LegacyEncoding = [
        'default' => false,
    ];
 
    public const AmericanDates = [
        'default' => false,
    ];
 
    public const TranslateNumerals = [
        'default' => true,
    ];
 
    public const UseDatabaseMessages = [
        'default' => true,
    ];
 
    public const MaxMsgCacheEntrySize = [
        'default' => 10000,
    ];
 
    public const DisableLangConversion = [
        'default' => false,
    ];
 
    public const DisableTitleConversion = [
        'default' => false,
    ];
 
    public const DefaultLanguageVariant = [
        'default' => false,
    ];
 
    public const UsePigLatinVariant = [
        'default' => false,
    ];
 
    public const DisabledVariants = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const VariantArticlePath = [
        'default' => false,
    ];
 
    public const UseXssLanguage = [
        'default' => false,
    ];
 
    public const LoginLanguageSelector = [
        'default' => false,
    ];
 
    public const ForceUIMsgAsContentMsg = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const RawHtmlMessages = [
        'default' => [
            'copyright',
            'history_copyright',
            'googlesearch',
            'youhavenewmessagesmanyusers',
            'youhavenewmessages',
        ],
        'type' => 'list',
        'items' => [ 'type' => 'string', ],
    ];
 
    public const Localtimezone = [
        'dynamicDefault' => true,
    ];
 
    public static function getDefaultLocaltimezone(): string {
        // This defaults to the `date.timezone` value of the PHP INI option. If this option is not set,
        // it falls back to UTC.
        $localtimezone = date_default_timezone_get();
        if ( !$localtimezone ) {
            // Make doubly sure we have a valid time zone, even if date_default_timezone_get()
            // returned garbage.
            $localtimezone = 'UTC';
        }
 
        return $localtimezone;
    }
 
    public const LocalTZoffset = [
        'dynamicDefault' => [ 'use' => [ 'Localtimezone' ] ]
    ];
 
    public static function getDefaultLocalTZoffset( $localtimezone ): int {
        // NOTE: Extra fallback, in case $localtimezone is ''.
        //       Many extsing LocalSettings files have $wgLocaltimezone = ''
        //       in them, erroneously generated by the installer.
        $localtimezone = $localtimezone ?: self::getDefaultLocaltimezone();
 
        $offset = ( new DateTimeZone( $localtimezone ) )->getOffset( new DateTime() );
        return (int)( $offset / 60 );
    }
 
    public const OverrideUcfirstCharacters = [
        'default' => [],
        'type' => 'map',
    ];
 
    // endregion -- End of language/charset settings
 
    /***************************************************************************/
    // region   Output format and skin settings
    public const MimeType = [
        'default' => 'text/html',
    ];
 
    public const Html5Version = [
        'default' => null,
    ];
 
    public const HTMLFormAllowTableFormat = [
        'default' => true,
    ];
 
    public const UseMediaWikiUIEverywhere = [
        'default' => false,
    ];
 
    public const EditSubmitButtonLabelPublish = [
        'default' => false,
    ];
 
    public const XhtmlNamespaces = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const SiteNotice = [
        'default' => '',
    ];
 
    public const BrowserFormatDetection = [
        'default' => 'telephone=no',
        'type' => 'string',
    ];
 
    public const SkinMetaTags = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const DefaultSkin = [
        'default' => 'vector-2022',
    ];
 
    public const FallbackSkin = [
        'default' => 'fallback',
    ];
 
    public const SkipSkins = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const DisableOutputCompression = [
        'default' => false,
    ];
 
    public const FragmentMode = [
        'default' => [ 'html5', 'legacy', ],
        'type' => 'list',
    ];
 
    public const ExternalInterwikiFragmentMode = [
        'default' => 'legacy',
    ];
 
    public const FooterIcons = [
        'default' => [
            "copyright" => [
                "copyright" => [], // placeholder for the built in copyright icon
            ],
            "poweredby" => [
                "mediawiki" => [
                    // Defaults to point at
                    // "$wgResourceBasePath/resources/assets/poweredby_mediawiki_88x31.png"
                    // plus srcset for 1.5x, 2x resolution variants.
                    "src" => null,
                    "url" => "https://www.mediawiki.org/",
                    "alt" => "Powered by MediaWiki",
                ]
            ],
        ],
        'type' => 'map',
    ];
 
    public const UseCombinedLoginLink = [
        'default' => false,
    ];
 
    public const Edititis = [
        'default' => false,
    ];
 
    public const Send404Code = [
        'default' => true,
    ];
 
    public const ShowRollbackEditCount = [
        'default' => 10,
    ];
 
    public const EnableCanonicalServerLink = [
        'default' => false,
    ];
 
    public const InterwikiLogoOverride = [
        'default' => [],
        'type' => 'list',
        'items' => [ 'type' => 'string', ],
    ];
 
    // endregion -- End of output format settings
 
    /***************************************************************************/
    // region   ResourceLoader settings
    public const MangleFlashPolicy = [
        'default' => true,
        'obsolete' => 'Since 1.39; no longer has any effect.',
        'description' => 'Has been emitting warnings since 1.39 (LTS). ' .
            'Can be removed completely in 1.44, assuming 1.43 is an LTS release.'
    ];
 
    public const ResourceModules = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ResourceModuleSkinStyles = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ResourceLoaderSources = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ResourceBasePath = [
        'default' => null,
        'dynamicDefault' => [ 'use' => [ 'ScriptPath' ] ]
    ];
 
    public static function getDefaultResourceBasePath( $scriptPath ): string {
        return $scriptPath;
    }
 
    public const ResourceLoaderMaxage = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ResourceLoaderUseObjectCacheForDeps = [
        'default' => false,
    ];
 
    public const ResourceLoaderDebug = [
        'default' => false,
    ];
 
    public const ResourceLoaderMaxQueryLength = [
        'default' => false,
        'type' => 'integer|false',
    ];
 
    public const ResourceLoaderValidateJS = [
        'default' => true,
    ];
 
    public const ResourceLoaderEnableJSProfiler = [
        'default' => false,
    ];
 
    public const ResourceLoaderStorageEnabled = [
        'default' => true,
    ];
 
    public const ResourceLoaderStorageVersion = [
        'default' => 1,
    ];
 
    public const ResourceLoaderEnableSourceMapLinks = [
        'default' => true,
    ];
 
    public const AllowSiteCSSOnRestrictedPages = [
        'default' => false,
    ];
 
    public const VueDevelopmentMode = [
        'default' => false,
    ];
 
    // endregion -- End of ResourceLoader settings
 
    /***************************************************************************/
    // region   Page titles and redirects
    public const MetaNamespace = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'Sitename' ] ]
    ];
 
    public static function getDefaultMetaNamespace( $sitename ): string {
        return str_replace( ' ', '_', $sitename );
    }
 
    public const MetaNamespaceTalk = [
        'default' => false,
    ];
 
    public const CanonicalNamespaceNames = [
        'default' => NamespaceInfo::CANONICAL_NAMES,
        'type' => 'map',
    ];
 
    public const ExtraNamespaces = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ExtraGenderNamespaces = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const NamespaceAliases = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const LegalTitleChars = [
        'default' => ' %!"$&\'()*,\\-.\\/0-9:;=?@A-Z\\\\^_`a-z~\\x80-\\xFF+',
        'deprecated' => 'since 1.41; use Extension:TitleBlacklist to customize',
    ];
 
    public const CapitalLinks = [
        'default' => true,
    ];
 
    public const CapitalLinkOverrides = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const NamespacesWithSubpages = [
        'default' => [
            NS_TALK => true,
            NS_USER => true,
            NS_USER_TALK => true,
            NS_PROJECT => true,
            NS_PROJECT_TALK => true,
            NS_FILE_TALK => true,
            NS_MEDIAWIKI => true,
            NS_MEDIAWIKI_TALK => true,
            NS_TEMPLATE => true,
            NS_TEMPLATE_TALK => true,
            NS_HELP => true,
            NS_HELP_TALK => true,
            NS_CATEGORY_TALK => true
        ],
        'type' => 'map',
    ];
 
    public const ContentNamespaces = [
        'default' => [ NS_MAIN ],
        'type' => 'list',
    ];
 
    public const ShortPagesNamespaceExclusions = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const ExtraSignatureNamespaces = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const InvalidRedirectTargets = [
        'default' => [ 'Filepath', 'Mypage', 'Mytalk', 'Redirect', 'Mylog' ],
        'type' => 'list',
    ];
 
    public const DisableHardRedirects = [
        'default' => false,
    ];
 
    public const FixDoubleRedirects = [
        'default' => false,
    ];
 
    // endregion -- End of title and interwiki settings
 
    /***************************************************************************/
    // region   Interwiki links and sites
    public const LocalInterwikis = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const InterwikiExpiry = [
        'default' => 10800,
    ];
 
    public const InterwikiCache = [
        'default' => false,
        'type' => 'false|map',
        'mergeStrategy' => 'replace',
    ];
 
    public const InterwikiScopes = [
        'default' => 3,
    ];
 
    public const InterwikiFallbackSite = [
        'default' => 'wiki',
    ];
 
    public const RedirectSources = [
        'default' => false,
    ];
 
    public const SiteTypes = [
        'default' => [ 'mediawiki' => MediaWikiSite::class, ],
        'type' => 'map',
    ];
 
    // endregion -- Interwiki links and sites
 
    /***************************************************************************/
    // region   Parser settings
    public const MaxTocLevel = [
        'default' => 999,
    ];
 
    public const MaxPPNodeCount = [
        'default' => 1000000,
    ];
 
    public const MaxTemplateDepth = [
        'default' => 100,
    ];
 
    public const MaxPPExpandDepth = [
        'default' => 100,
    ];
 
    public const UrlProtocols = [
        'default' => [
            'bitcoin:', 'ftp://', 'ftps://', 'geo:', 'git://', 'gopher://', 'http://',
            'https://', 'irc://', 'ircs://', 'magnet:', 'mailto:', 'matrix:', 'mms://',
            'news:', 'nntp://', 'redis://', 'sftp://', 'sip:', 'sips:', 'sms:',
            'ssh://', 'svn://', 'tel:', 'telnet://', 'urn:', 'worldwind://', 'xmpp:',
            '//',
        ],
        'type' => 'list',
    ];
 
    public const CleanSignatures = [
        'default' => true,
    ];
 
    public const AllowExternalImages = [
        'default' => false,
    ];
 
    public const AllowExternalImagesFrom = [
        'default' => '',
    ];
 
    public const EnableImageWhitelist = [
        'default' => false,
    ];
 
    public const AllowImageTag = [
        'default' => false,
        'deprecated' => 'since 1.35; register an extension tag named <img> instead.',
    ];
 
    public const TidyConfig = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ParsoidSettings = [
        'default' => [
            'useSelser' => true,
        ],
        'type' => 'map',
    ];
 
    public const ParserEnableLegacyMediaDOM = [
        'default' => false,
        'deprecated' => 'since 1.41',
    ];
 
    public const UseContentMediaStyles = [
        'default' => false,
        'deprecated' => 'since 1.41',
    ];
 
    public const UseLegacyMediaStyles = [
        'default' => false,
    ];
 
    public const RawHtml = [
        'default' => false,
    ];
 
    public const ExternalLinkTarget = [
        'default' => false,
    ];
 
    public const NoFollowLinks = [
        'default' => true,
    ];
 
    public const NoFollowNsExceptions = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const NoFollowDomainExceptions = [
        'default' => [ 'mediawiki.org', ],
        'type' => 'list',
    ];
 
    public const RegisterInternalExternals = [
        'default' => false,
    ];
 
    public const AllowDisplayTitle = [
        'default' => true,
    ];
 
    public const RestrictDisplayTitle = [
        'default' => true,
    ];
 
    public const ExpensiveParserFunctionLimit = [
        'default' => 100,
    ];
 
    public const PreprocessorCacheThreshold = [
        'default' => 1000,
    ];
 
    public const EnableScaryTranscluding = [
        'default' => false,
    ];
 
    public const TranscludeCacheExpiry = [
        'default' => 3600,
    ];
 
    public const EnableMagicLinks = [
        'default' => [
            'ISBN' => false,
            'PMID' => false,
            'RFC' => false,
        ],
        'type' => 'map',
    ];
 
    // endregion -- end of parser settings
 
    /***************************************************************************/
    // region   Statistics and content analysis
    public const ArticleCountMethod = [
        'default' => 'link',
    ];
 
    public const ActiveUserDays = [
        'default' => 30,
    ];
 
    public const LearnerEdits = [
        'default' => 10,
    ];
 
    public const LearnerMemberSince = [
        'default' => 4,
    ];
 
    public const ExperiencedUserEdits = [
        'default' => 500,
    ];
 
    public const ExperiencedUserMemberSince = [
        'default' => 30,
    ];
 
    public const ManualRevertSearchRadius = [
        'default' => 15,
        'type' => 'integer',
    ];
 
    public const RevertedTagMaxDepth = [
        'default' => 15,
        'type' => 'integer',
    ];
 
    // endregion -- End of statistics and content analysis
 
    /***************************************************************************/
    // region   User accounts, authentication
    public const CentralIdLookupProviders = [
        'default' => [
            'local' => [
                'class' => LocalIdLookup::class,
                'services' => [
                    'MainConfig',
                    'DBLoadBalancerFactory',
                    'HideUserUtils',
                ]
            ]
        ],
        'type' => 'map',
    ];
 
    public const CentralIdLookupProvider = [
        'default' => 'local',
        'type' => 'string',
    ];
 
    public const UserRegistrationProviders = [
        'default' => [
            LocalUserRegistrationProvider::TYPE => [
                'class' => LocalUserRegistrationProvider::class,
                'services' => [
                    'UserFactory'
                ]
            ]
        ],
        'type' => 'map',
    ];
 
    public const PasswordPolicy = [
        'default' => [
            'policies' => [
                'bureaucrat' => [
                    'MinimalPasswordLength' => 10,
                    'MinimumPasswordLengthToLogin' => 1,
                ],
                'sysop' => [
                    'MinimalPasswordLength' => 10,
                    'MinimumPasswordLengthToLogin' => 1,
                ],
                'interface-admin' => [
                    'MinimalPasswordLength' => 10,
                    'MinimumPasswordLengthToLogin' => 1,
                ],
                'bot' => [
                    'MinimalPasswordLength' => 10,
                    'MinimumPasswordLengthToLogin' => 1,
                ],
                'default' => [
                    'MinimalPasswordLength' => [ 'value' => 8, 'suggestChangeOnLogin' => true ],
                    'PasswordCannotBeSubstringInUsername' => [
                        'value' => true,
                        'suggestChangeOnLogin' => true
                    ],
                    'PasswordCannotMatchDefaults' => [ 'value' => true, 'suggestChangeOnLogin' => true ],
                    'MaximalPasswordLength' => [ 'value' => 4096, 'suggestChangeOnLogin' => true ],
                    'PasswordNotInCommonList' => [ 'value' => true, 'suggestChangeOnLogin' => true ],
                ],
            ],
            'checks' => [
                'MinimalPasswordLength' => 'PasswordPolicyChecks::checkMinimalPasswordLength',
                'MinimumPasswordLengthToLogin' => 'PasswordPolicyChecks::checkMinimumPasswordLengthToLogin',
                'PasswordCannotBeSubstringInUsername' =>
                    'PasswordPolicyChecks::checkPasswordCannotBeSubstringInUsername',
                'PasswordCannotMatchDefaults' => 'PasswordPolicyChecks::checkPasswordCannotMatchDefaults',
                'MaximalPasswordLength' => 'PasswordPolicyChecks::checkMaximalPasswordLength',
                'PasswordNotInCommonList' => 'PasswordPolicyChecks::checkPasswordNotInCommonList',
            ],
        ],
        'type' => 'map',
        'mergeStrategy' => 'array_replace_recursive',
    ];
 
    public const AuthManagerConfig = [
        'default' => null,
        'type' => '?map',
    ];
 
    public const AuthManagerAutoConfig = [
        'default' => [
            'preauth' => [
                \MediaWiki\Auth\ThrottlePreAuthenticationProvider::class => [
                    'class' => \MediaWiki\Auth\ThrottlePreAuthenticationProvider::class,
                    'sort' => 0,
                ],
            ],
            'primaryauth' => [
                // TemporaryPasswordPrimaryAuthenticationProvider should come before
                // any other PasswordAuthenticationRequest-based
                // PrimaryAuthenticationProvider (or at least any that might return
                // FAIL rather than ABSTAIN for a wrong password), or password reset
                // won't work right. Do not remove this (or change the key) or
                // auto-configuration of other such providers in extensions will
                // probably auto-insert themselves in the wrong place.
                \MediaWiki\Auth\TemporaryPasswordPrimaryAuthenticationProvider::class => [
                    'class' => \MediaWiki\Auth\TemporaryPasswordPrimaryAuthenticationProvider::class,
                    'services' => [
                        'DBLoadBalancerFactory',
                        'UserOptionsLookup',
                    ],
                    'args' => [ [
                        // Fall through to LocalPasswordPrimaryAuthenticationProvider
                        'authoritative' => false,
                    ] ],
                    'sort' => 0,
                ],
                \MediaWiki\Auth\LocalPasswordPrimaryAuthenticationProvider::class => [
                    'class' => \MediaWiki\Auth\LocalPasswordPrimaryAuthenticationProvider::class,
                    'services' => [
                        'DBLoadBalancerFactory',
                    ],
                    'args' => [ [
                        // Last one should be authoritative, or else the user will get
                        // a less-than-helpful error message (something like "supplied
                        // authentication info not supported" rather than "wrong
                        // password") if it too fails.
                        'authoritative' => true,
                    ] ],
                    'sort' => 100,
                ],
            ],
            'secondaryauth' => [
                \MediaWiki\Auth\CheckBlocksSecondaryAuthenticationProvider::class => [
                    'class' => \MediaWiki\Auth\CheckBlocksSecondaryAuthenticationProvider::class,
                    'sort' => 0,
                ],
                \MediaWiki\Auth\ResetPasswordSecondaryAuthenticationProvider::class => [
                    'class' => \MediaWiki\Auth\ResetPasswordSecondaryAuthenticationProvider::class,
                    'sort' => 100,
                ],
                // Linking during login is experimental, enable at your own risk - T134952
                // MediaWiki\Auth\ConfirmLinkSecondaryAuthenticationProvider::class => [
                //   'class' => MediaWiki\Auth\ConfirmLinkSecondaryAuthenticationProvider::class,
                //   'sort' => 100,
                // ],
                \MediaWiki\Auth\EmailNotificationSecondaryAuthenticationProvider::class => [
                    'class' => \MediaWiki\Auth\EmailNotificationSecondaryAuthenticationProvider::class,
                    'services' => [
                        'DBLoadBalancerFactory',
                    ],
                    'sort' => 200,
                ],
            ],
        ],
        'type' => 'map',
        'mergeStrategy' => 'array_plus_2d',
    ];
 
    public const RememberMe = [
        'default' => 'choose',
        'type' => 'string',
    ];
 
    public const ReauthenticateTime = [
        'default' => [ 'default' => 300, ],
        'type' => 'map',
        'additionalProperties' => [ 'type' => 'integer', ],
    ];
 
    public const AllowSecuritySensitiveOperationIfCannotReauthenticate = [
        'default' => [ 'default' => true, ],
        'type' => 'map',
        'additionalProperties' => [ 'type' => 'boolean', ],
    ];
 
    public const ChangeCredentialsBlacklist = [
        'default' => [
            \MediaWiki\Auth\TemporaryPasswordAuthenticationRequest::class,
        ],
        'type' => 'list',
        'items' => [ 'type' => 'string', ],
    ];
 
    public const RemoveCredentialsBlacklist = [
        'default' => [
            \MediaWiki\Auth\PasswordAuthenticationRequest::class,
        ],
        'type' => 'list',
        'items' => [ 'type' => 'string', ],
    ];
 
    public const MinimalPasswordLength = [
        'default' => false,
        'deprecated' => 'since 1.26, use $wgPasswordPolicy\'s MinimalPasswordLength.',
    ];
 
    public const MaximalPasswordLength = [
        'default' => false,
        'deprecated' => 'since 1.26, use $wgPasswordPolicy\'s MaximalPasswordLength.',
    ];
 
    public const InvalidPasswordReset = [
        'default' => true,
    ];
 
    public const PasswordDefault = [
        'default' => 'pbkdf2',
    ];
 
    public const PasswordConfig = [
        'default' => [
            'A' => [
                'class' => MWOldPassword::class,
            ],
            'B' => [
                'class' => MWSaltedPassword::class,
            ],
            'pbkdf2-legacyA' => [
                'class' => LayeredParameterizedPassword::class,
                'types' => [
                    'A',
                    'pbkdf2',
                ],
            ],
            'pbkdf2-legacyB' => [
                'class' => LayeredParameterizedPassword::class,
                'types' => [
                    'B',
                    'pbkdf2',
                ],
            ],
            'bcrypt' => [
                'class' => BcryptPassword::class,
                'cost' => 9,
            ],
            'pbkdf2' => [
                'factory' => [ AbstractPbkdf2Password::class, 'newInstance' ],
                'algo' => 'sha512',
                'cost' => '30000',
                'length' => '64',
            ],
            'argon2' => [
                'class' => Argon2Password::class,
 
                // Algorithm used:
                // * 'argon2i' is optimized against side-channel attacks
                // * 'argon2id' is optimized against both side-channel and GPU cracking
                // * 'auto' to use best available algorithm. If you're using more than one server, be
                //   careful when you're mixing PHP versions because newer PHP might generate hashes that
                //   older versions might would not understand.
                'algo' => 'auto',
 
                // The parameters below are the same as options accepted by password_hash().
                // Set them to override that function's defaults.
                //
                // 'memory_cost' => PASSWORD_ARGON2_DEFAULT_MEMORY_COST,
                // 'time_cost' => PASSWORD_ARGON2_DEFAULT_TIME_COST,
                // 'threads' => PASSWORD_ARGON2_DEFAULT_THREADS,
            ],
        ],
        'type' => 'map',
    ];
 
    public const PasswordResetRoutes = [
        'default' => [
            'username' => true,
            'email' => true,
        ],
        'type' => 'map',
    ];
 
    public const MaxSigChars = [
        'default' => 255,
    ];
 
    public const SignatureValidation = [
        'default' => 'warning',
    ];
 
    public const SignatureAllowedLintErrors = [
        'default' => [ 'obsolete-tag', ],
        'type' => 'list',
    ];
 
    public const MaxNameChars = [
        'default' => 255,
    ];
 
    public const ReservedUsernames = [
        'default' => [
            'MediaWiki default', // Default 'Main Page' and MediaWiki: message pages
            'Conversion script', // Used for the old Wikipedia software upgrade
            'Maintenance script', // Maintenance scripts which perform editing, image import script
            'Template namespace initialisation script', // Used in 1.2->1.3 upgrade
            'ScriptImporter', // Default user name used by maintenance/importSiteScripts.php
            'Delete page script', // Default user name used by maintenance/deleteBatch.php
            'Move page script', // Default user name used by maintenance/deleteBatch.php
            'Command line script', // Default user name used by maintenance/undelete.php
            'Unknown user', // Used in WikiImporter & RevisionStore for revisions with no author and in User for invalid user id
            'msg:double-redirect-fixer', // Automatic double redirect fix
            'msg:usermessage-editor', // Default user for leaving user messages
            'msg:proxyblocker', // For $wgProxyList and Special:Blockme (removed in 1.22)
            'msg:sorbs', // For $wgEnableDnsBlacklist etc.
            'msg:spambot_username', // Used by cleanupSpam.php
            'msg:autochange-username', // Used by anon category RC entries (parser functions, Lua & purges)
        ],
        'type' => 'list',
    ];
 
    public const DefaultUserOptions = [
        'default' =>
            // This array should be sorted by key
            [
                'ccmeonemails' => 0,
                'date' => 'default',
                'diffonly' => 0,
                'diff-type' => 'table',
                'disablemail' => 0,
                'editfont' => 'monospace',
                'editondblclick' => 0,
                'editsectiononrightclick' => 0,
                'email-allow-new-users' => 1,
                'enotifminoredits' => 0,
                'enotifrevealaddr' => 0,
                'enotifusertalkpages' => 1,
                'enotifwatchlistpages' => 1,
                'extendwatchlist' => 1,
                'fancysig' => 0,
                'forceeditsummary' => 0,
                'forcesafemode' => 0,
                'gender' => 'unknown',
                'hidecategorization' => 1,
                'hideminor' => 0,
                'hidepatrolled' => 0,
                'imagesize' => 2,
                'minordefault' => 0,
                'newpageshidepatrolled' => 0,
                'nickname' => '',
                'norollbackdiff' => 0,
                'prefershttps' => 1,
                'previewonfirst' => 0,
                'previewontop' => 1,
                'pst-cssjs' => 1,
                'rcdays' => 7,
                'rcenhancedfilters-disable' => 0,
                'rclimit' => 50,
                'requireemail' => 0,
                'search-match-redirect' => true,
                'search-special-page' => 'Search',
                'search-thumbnail-extra-namespaces' => true,
                'searchlimit' => 20,
                'showhiddencats' => 0,
                'shownumberswatching' => 1,
                'showrollbackconfirmation' => 0,
                'skin' => false,
                'skin-responsive' => 1,
                'thumbsize' => 5,
                'underline' => 2,
                'useeditwarning' => 1,
                'uselivepreview' => 0,
                'usenewrc' => 1,
                'watchcreations' => 1,
                'watchdefault' => 1,
                'watchdeletion' => 0,
                'watchlistdays' => 7,
                'watchlisthideanons' => 0,
                'watchlisthidebots' => 0,
                'watchlisthidecategorization' => 1,
                'watchlisthideliu' => 0,
                'watchlisthideminor' => 0,
                'watchlisthideown' => 0,
                'watchlisthidepatrolled' => 0,
                'watchlistreloadautomatically' => 0,
                'watchlistunwatchlinks' => 0,
                'watchmoves' => 0,
                'watchrollback' => 0,
                'watchuploads' => 1,
                'wlenhancedfilters-disable' => 0,
                'wllimit' => 250,
            ],
        'type' => 'map',
    ];
 
    public const HiddenPrefs = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const InvalidUsernameCharacters = [
        'default' => '@:>=',
    ];
 
    public const UserrightsInterwikiDelimiter = [
        'default' => '@',
    ];
 
    public const SecureLogin = [
        'default' => false,
    ];
 
    public const AuthenticationTokenVersion = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const SessionProviders = [
        'type' => 'map',
        'default' => [
            \MediaWiki\Session\CookieSessionProvider::class => [
                'class' => \MediaWiki\Session\CookieSessionProvider::class,
                'args' => [ [
                    'priority' => 30,
                ] ],
            ],
            \MediaWiki\Session\BotPasswordSessionProvider::class => [
                'class' => \MediaWiki\Session\BotPasswordSessionProvider::class,
                'args' => [ [
                    'priority' => 75,
                ] ],
                'services' => [
                    'GrantsInfo'
                ],
            ],
        ],
    ];
 
    public const AllowRequiringEmailForResets = [
        'default' => false,
    ];
 
    public const AutoCreateTempUser = [
        'properties' => [
            'enabled' => [ 'type' => 'bool', 'default' => false ],
            'actions' => [ 'type' => 'list', 'default' => [ 'edit' ] ],
            'genPattern' => [ 'type' => 'string', 'default' => '*Unregistered $1' ],
            'matchPattern' => [ 'type' => 'string', 'default' => '*$1' ],
            'reservedPattern' => [ 'type' => 'string|null', 'default' => null ],
            'serialProvider' => [ 'type' => 'object', 'default' => [ 'type' => 'local' ] ],
            'serialMapping' => [ 'type' => 'object', 'default' => [ 'type' => 'plain-numeric' ] ],
            'expireAfterDays' => [ 'type' => 'int|null', 'default' => null ],
            'notifyBeforeExpirationDays' => [ 'type' => 'int|null', 'default' => null ],
        ],
        'type' => 'object',
    ];
 
    // endregion -- end user accounts
 
    /***************************************************************************/
    // region   User rights, access control and monitoring
    public const AutoblockExpiry = [
        'default' => 86400,
    ];
 
    public const BlockAllowsUTEdit = [
        'default' => true,
    ];
 
    public const BlockCIDRLimit = [
        'default' => [
            'IPv4' => 16,
            'IPv6' => 19,
        ],
        'type' => 'map',
    ];
 
    public const BlockDisablesLogin = [
        'default' => false,
    ];
 
    public const EnablePartialActionBlocks = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const EnableMultiBlocks = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const BlockTargetMigrationStage = [
        'default' => SCHEMA_COMPAT_OLD,
        'type' => 'integer',
    ];
 
    public const WhitelistRead = [
        'default' => false,
    ];
 
    public const WhitelistReadRegexp = [
        'default' => false,
    ];
 
    public const EmailConfirmToEdit = [
        'default' => false,
    ];
 
    public const HideIdentifiableRedirects = [
        'default' => true,
    ];
 
    public const GroupPermissions = [
        'type' => 'map',
        'additionalProperties' => [
            'type' => 'map',
            'additionalProperties' => [ 'type' => 'boolean', ],
        ],
        'mergeStrategy' => 'array_plus_2d',
        'default' => [
            '*' => [
                'createaccount' => true,
                'read' => true,
                'edit' => true,
                'createpage' => true,
                'createtalk' => true,
                'writeapi' => true,
                'viewmyprivateinfo' => true,
                'editmyprivateinfo' => true,
                'editmyoptions' => true,
            ],
            'user' => [
                'move' => true,
                'move-subpages' => true,
                'move-rootuserpages' => true,
                'move-categorypages' => true,
                'movefile' => true,
                'read' => true,
                'edit' => true,
                'createpage' => true,
                'createtalk' => true,
                'writeapi' => true,
                'upload' => true,
                'reupload' => true,
                'reupload-shared' => true,
                'minoredit' => true,
                'editmyusercss' => true,
                'editmyuserjson' => true,
                'editmyuserjs' => true,
                'editmyuserjsredirect' => true,
                'sendemail' => true,
                'applychangetags' => true,
                'changetags' => true,
                'editcontentmodel' => true,
                'viewmywatchlist' => true,
                'editmywatchlist' => true,
            ],
            'autoconfirmed' => [
                'autoconfirmed' => true,
                'editsemiprotected' => true,
            ],
            'bot' => [
                'bot' => true,
                'autoconfirmed' => true,
                'editsemiprotected' => true,
                'nominornewtalk' => true,
                'autopatrol' => true,
                'suppressredirect' => true,
                'apihighlimits' => true,
                'writeapi' => true,
            ],
            'sysop' => [
                'block' => true,
                'createaccount' => true,
                'delete' => true,
                'bigdelete' => true,
                'deletedhistory' => true,
                'deletedtext' => true,
                'undelete' => true,
                'editinterface' => true,
                'editsitejson' => true,
                'edituserjson' => true,
                'import' => true,
                'importupload' => true,
                'move' => true,
                'move-subpages' => true,
                'move-rootuserpages' => true,
                'move-categorypages' => true,
                'patrol' => true,
                'autopatrol' => true,
                'protect' => true,
                'editprotected' => true,
                'rollback' => true,
                'upload' => true,
                'reupload' => true,
                'reupload-shared' => true,
                'unwatchedpages' => true,
                'autoconfirmed' => true,
                'editsemiprotected' => true,
                'ipblock-exempt' => true,
                'blockemail' => true,
                'markbotedits' => true,
                'apihighlimits' => true,
                'browsearchive' => true,
                'noratelimit' => true,
                'movefile' => true,
                'unblockself' => true,
                'suppressredirect' => true,
                'mergehistory' => true,
                'managechangetags' => true,
                'deletechangetags' => true,
            ],
            'interface-admin' => [
                'editinterface' => true,
                'editsitecss' => true,
                'editsitejson' => true,
                'editsitejs' => true,
                'editusercss' => true,
                'edituserjson' => true,
                'edituserjs' => true,
            ],
            'bureaucrat' => [
                'userrights' => true,
                'noratelimit' => true,
                'renameuser' => true,
            ],
            'suppress' => [
                'hideuser' => true,
                'suppressrevision' => true,
                'viewsuppressed' => true,
                'suppressionlog' => true,
                'deleterevision' => true,
                'deletelogentry' => true,
            ],
        ],
    ];
 
    public const PrivilegedGroups = [
        'default' => [
            'bureaucrat',
            'interface-admin',
            'suppress',
            'sysop',
        ],
        'type' => 'list',
    ];
 
    public const RevokePermissions = [
        'default' => [],
        'type' => 'map',
        'mergeStrategy' => 'array_plus_2d',
    ];
 
    public const GroupInheritsPermissions = [
        'default' => [],
        'type' => 'map',
        'additionalProperties' => [ 'type' => 'string', ],
    ];
 
    public const ImplicitGroups = [
        'default' => [ '*', 'user', 'autoconfirmed' ],
        'type' => 'list',
    ];
 
    public const GroupsAddToSelf = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const GroupsRemoveFromSelf = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const RestrictionTypes = [
        'default' => [ 'create', 'edit', 'move', 'upload' ],
        'type' => 'list',
    ];
 
    public const RestrictionLevels = [
        'default' => [ '', 'autoconfirmed', 'sysop' ],
        'type' => 'list',
    ];
 
    public const CascadingRestrictionLevels = [
        'default' => [ 'sysop', ],
        'type' => 'list',
    ];
 
    public const SemiprotectedRestrictionLevels = [
        'default' => [ 'autoconfirmed', ],
        'type' => 'list',
    ];
 
    public const NamespaceProtection = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const NonincludableNamespaces = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const AutoConfirmAge = [
        'default' => 0,
    ];
 
    public const AutoConfirmCount = [
        'default' => 0,
    ];
 
    public const Autopromote = [
        'default' => [
            'autoconfirmed' => [ '&',
                [ APCOND_EDITCOUNT, null ], // NOTE: null means $wgAutoConfirmCount
                [ APCOND_AGE, null ], // NOTE: null means AutoConfirmAge
            ],
        ],
        'type' => 'map',
    ];
 
    public const AutopromoteOnce = [
        'default' => [ 'onEdit' => [], ],
        'type' => 'map',
    ];
 
    public const AutopromoteOnceLogInRC = [
        'default' => true,
    ];
 
    public const AddGroups = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const RemoveGroups = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const AvailableRights = [
        'default' => [],
        'type' => 'list',
        'items' => [ 'type' => 'string', ],
    ];
 
    public const ImplicitRights = [
        'default' => [],
        'type' => 'list',
        'items' => [ 'type' => 'string', ]
    ];
 
    public const DeleteRevisionsLimit = [
        'default' => 0,
    ];
 
    public const DeleteRevisionsBatchSize = [
        'default' => 1000,
    ];
 
    public const HideUserContribLimit = [
        'default' => 1000,
    ];
 
    public const AccountCreationThrottle = [
        'default' => [ [
            'count' => 0,
            'seconds' => 86400,
        ] ],
        'type' => 'int|list',
    ];
 
    public const SpamRegex = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const SummarySpamRegex = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const EnableDnsBlacklist = [
        'default' => false,
    ];
 
    public const DnsBlacklistUrls = [
        'default' => [ 'http.dnsbl.sorbs.net.', ],
        'type' => 'list',
    ];
 
    public const ProxyList = [
        'default' => [],
        'type' => 'string|list',
    ];
 
    public const ProxyWhitelist = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const SoftBlockRanges = [
        'default' => [],
        'type' => 'list',
        'items' => [ 'type' => 'string', ],
    ];
 
    public const ApplyIpBlocksToXff = [
        'default' => false,
    ];
 
    public const RateLimits = [
        'default' => [
            // Page edits
            'edit' => [
                'ip' => [ 8, 60 ],
                'newbie' => [ 8, 60 ],
                'user' => [ 90, 60 ],
            ],
            // Page moves
            'move' => [
                'newbie' => [ 2, 120 ],
                'user' => [ 8, 60 ],
            ],
            // File uploads
            'upload' => [
                'ip' => [ 8, 60 ],
                'newbie' => [ 8, 60 ],
            ],
            // Page rollbacks
            'rollback' => [
                'user' => [ 10, 60 ],
                'newbie' => [ 5, 120 ]
            ],
            // Triggering password resets emails
            'mailpassword' => [
                'ip' => [ 5, 3600 ],
            ],
            // Emailing other users using MediaWiki
            'sendemail' => [
                'ip' => [ 5, 86400 ],
                'newbie' => [ 5, 86400 ],
                'user' => [ 20, 86400 ],
            ],
            'changeemail' => [
                'ip-all' => [ 10, 3600 ],
                'user' => [ 4, 86400 ]
            ],
            // since 1.33 - rate limit email confirmations
            'confirmemail' => [
                'ip-all' => [ 10, 3600 ],
                'user' => [ 4, 86400 ]
            ],
            // Purging pages
            'purge' => [
                'ip' => [ 30, 60 ],
                'user' => [ 30, 60 ],
            ],
            // Purges of link tables
            'linkpurge' => [
                'ip' => [ 30, 60 ],
                'user' => [ 30, 60 ],
            ],
            // Files rendered via thumb.php or thumb_handler.php
            'renderfile' => [
                'ip' => [ 700, 30 ],
                'user' => [ 700, 30 ],
            ],
            // Same as above but for non-standard thumbnails
            'renderfile-nonstandard' => [
                'ip' => [ 70, 30 ],
                'user' => [ 70, 30 ],
            ],
            // Stashing edits into cache before save
            'stashedit' => [
                'ip' => [ 30, 60 ],
                'newbie' => [ 30, 60 ],
            ],
            // Stash base HTML for VE edits
            'stashbasehtml' => [
                'ip' => [ 5, 60 ],
                'newbie' => [ 5, 60 ],
            ],
            // Adding or removing change tags
            'changetags' => [
                'ip' => [ 8, 60 ],
                'newbie' => [ 8, 60 ],
            ],
            // Changing the content model of a page
            'editcontentmodel' => [
                'newbie' => [ 2, 120 ],
                'user' => [ 8, 60 ],
            ],
        ],
        'type' => 'map',
        'mergeStrategy' => 'array_plus_2d',
    ];
 
    public const RateLimitsExcludedIPs = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const PutIPinRC = [
        'default' => true,
    ];
 
    public const QueryPageDefaultLimit = [
        'default' => 50,
    ];
 
    public const PasswordAttemptThrottle = [
        'default' => [
            // Short term limit
            [ 'count' => 5, 'seconds' => 300 ],
            // Long term limit. We need to balance the risk
            // of somebody using this as a DoS attack to lock someone
            // out of their account, and someone doing a brute force attack.
            [ 'count' => 150, 'seconds' => 60 * 60 * 48 ],
        ],
        'type' => 'list',
    ];
 
    public const GrantPermissions = [
        'default' => [
            'basic' => [
                'autocreateaccount' => true,
                'autoconfirmed' => true,
                'autopatrol' => true,
                'editsemiprotected' => true,
                'ipblock-exempt' => true,
                'nominornewtalk' => true,
                'patrolmarks' => true,
                'read' => true,
                'writeapi' => true,
                'unwatchedpages' => true,
            ],
            'highvolume' => [
                'bot' => true,
                'apihighlimits' => true,
                'noratelimit' => true,
                'markbotedits' => true,
            ],
            'import' => [
                'import' => true,
                'importupload' => true,
            ],
            'editpage' => [
                'edit' => true,
                'minoredit' => true,
                'applychangetags' => true,
                'changetags' => true,
                'editcontentmodel' => true,
            ],
            'editprotected' => [
                'edit' => true,
                'minoredit' => true,
                'applychangetags' => true,
                'changetags' => true,
                'editcontentmodel' => true,
                'editprotected' => true,
            ],
            'editmycssjs' => [
                'edit' => true,
                'minoredit' => true,
                'applychangetags' => true,
                'changetags' => true,
                'editcontentmodel' => true,
                'editmyusercss' => true,
                'editmyuserjson' => true,
                'editmyuserjs' => true,
            ],
            'editmyoptions' => [
                'editmyoptions' => true,
                'editmyuserjson' => true,
            ],
            'editinterface' => [
                'edit' => true,
                'minoredit' => true,
                'applychangetags' => true,
                'changetags' => true,
                'editcontentmodel' => true,
                'editinterface' => true,
                'edituserjson' => true,
                'editsitejson' => true,
            ],
            'editsiteconfig' => [
                'edit' => true,
                'minoredit' => true,
                'applychangetags' => true,
                'changetags' => true,
                'editcontentmodel' => true,
                'editinterface' => true,
                'edituserjson' => true,
                'editsitejson' => true,
                'editusercss' => true,
                'edituserjs' => true,
                'editsitecss' => true,
                'editsitejs' => true,
            ],
            'createeditmovepage' => [
                'edit' => true,
                'minoredit' => true,
                'applychangetags' => true,
                'changetags' => true,
                'editcontentmodel' => true,
                'createpage' => true,
                'createtalk' => true,
                'delete-redirect' => true,
                'move' => true,
                'move-rootuserpages' => true,
                'move-subpages' => true,
                'move-categorypages' => true,
                'suppressredirect' => true,
            ],
            'uploadfile' => [
                'upload' => true,
                'reupload-own' => true,
            ],
            'uploadeditmovefile' => [
                'upload' => true,
                'reupload-own' => true,
                'reupload' => true,
                'reupload-shared' => true,
                'upload_by_url' => true,
                'movefile' => true,
                'suppressredirect' => true,
            ],
            'patrol' => [
                'patrol' => true,
            ],
            'rollback' => [
                'rollback' => true,
            ],
            'blockusers' => [
                'block' => true,
                'blockemail' => true,
            ],
            'viewdeleted' => [
                'browsearchive' => true,
                'deletedhistory' => true,
                'deletedtext' => true,
            ],
            'viewrestrictedlogs' => [
                'suppressionlog' => true,
            ],
            'delete' => [
                'edit' => true,
                'minoredit' => true,
                'applychangetags' => true,
                'changetags' => true,
                'editcontentmodel' => true,
                'browsearchive' => true,
                'deletedhistory' => true,
                'deletedtext' => true,
                'delete' => true,
                'bigdelete' => true,
                'deletelogentry' => true,
                'deleterevision' => true,
                'undelete' => true,
            ],
            'oversight' => [
                'suppressrevision' => true,
                'viewsuppressed' => true,
            ],
            'protect' => [
                'edit' => true,
                'minoredit' => true,
                'applychangetags' => true,
                'changetags' => true,
                'editcontentmodel' => true,
                'editprotected' => true,
                'protect' => true,
            ],
            'viewmywatchlist' => [
                'viewmywatchlist' => true,
            ],
            'editmywatchlist' => [
                'editmywatchlist' => true,
            ],
            'sendemail' => [
                'sendemail' => true,
            ],
            'createaccount' => [
                'createaccount' => true,
            ],
            'privateinfo' => [
                'viewmyprivateinfo' => true,
            ],
            'mergehistory' => [
                'mergehistory' => true,
            ],
        ],
        'type' => 'map',
        'mergeStrategy' => 'array_plus_2d',
        'additionalProperties' => [
            'type' => 'map',
            'additionalProperties' => [ 'type' => 'boolean', ],
        ],
    ];
 
    public const GrantPermissionGroups = [
        'default' =>
            [
                // Hidden grants are implicitly present
                'basic'            => 'hidden',
 
                'editpage'            => 'page-interaction',
                'createeditmovepage'  => 'page-interaction',
                'editprotected'       => 'page-interaction',
                'patrol'              => 'page-interaction',
 
                'uploadfile'          => 'file-interaction',
                'uploadeditmovefile'  => 'file-interaction',
 
                'sendemail'           => 'email',
 
                'viewmywatchlist'     => 'watchlist-interaction',
                'editviewmywatchlist' => 'watchlist-interaction',
 
                'editmycssjs'         => 'customization',
                'editmyoptions'       => 'customization',
 
                'editinterface'       => 'administration',
                'editsiteconfig'      => 'administration',
                'rollback'            => 'administration',
                'blockusers'          => 'administration',
                'delete'              => 'administration',
                'viewdeleted'         => 'administration',
                'viewrestrictedlogs'  => 'administration',
                'protect'             => 'administration',
                'oversight'           => 'administration',
                'createaccount'       => 'administration',
                'mergehistory'        => 'administration',
                'import'              => 'administration',
 
                'highvolume'          => 'high-volume',
 
                'privateinfo'         => 'private-information',
            ],
        'type' => 'map',
        'additionalProperties' => [ 'type' => 'string', ],
    ];
 
    public const EnableBotPasswords = [
        'default' => true,
        'type' => 'boolean',
    ];
 
    public const BotPasswordsCluster = [
        'default' => false,
        'type' => 'string|false',
    ];
 
    public const BotPasswordsDatabase = [
        'default' => false,
        'type' => 'string|false',
    ];
 
    // endregion -- end of user rights settings
 
    /***************************************************************************/
    // region   Security
    public const SecretKey = [
        'default' => false,
    ];
 
    public const AllowUserJs = [
        'default' => false,
    ];
 
    public const AllowUserCss = [
        'default' => false,
    ];
 
    public const AllowUserCssPrefs = [
        'default' => true,
    ];
 
    public const UseSiteJs = [
        'default' => true,
    ];
 
    public const UseSiteCss = [
        'default' => true,
    ];
 
    public const BreakFrames = [
        'default' => false,
    ];
 
    public const EditPageFrameOptions = [
        'default' => 'DENY',
    ];
 
    public const ApiFrameOptions = [
        'default' => 'DENY',
    ];
 
    public const CSPHeader = [
        'default' => false,
        'type' => 'false|object',
    ];
 
    public const CSPReportOnlyHeader = [
        'default' => false,
        'type' => 'false|object',
    ];
 
    public const CSPFalsePositiveUrls = [
        'default' => [
            'https://3hub.co' => true,
            'https://morepro.info' => true,
            'https://p.ato.mx' => true,
            'https://s.ato.mx' => true,
            'https://adserver.adtech.de' => true,
            'https://ums.adtechus.com' => true,
            'https://cas.criteo.com' => true,
            'https://cat.nl.eu.criteo.com' => true,
            'https://atpixel.alephd.com' => true,
            'https://rtb.metrigo.com' => true,
            'https://d5p.de17a.com' => true,
            'https://ad.lkqd.net/vpaid/vpaid.js' => true,
            'https://ad.lkqd.net/vpaid/vpaid.js?fusion=1.0' => true,
            'https://t.lkqd.net/t' => true,
            'chrome-extension' => true,
        ],
        'type' => 'map',
    ];
 
    public const AllowCrossOrigin = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const RestAllowCrossOriginCookieAuth = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const SessionSecret = [
        'default' => false,
    ];
 
    public const SessionInsecureSecrets = [
        'default' => false,
    ];
 
    public const HKDFSecret = [
        'default' => false,
    ];
 
    public const HKDFAlgorithm = [
        'default' => 'sha256',
    ];
 
    // endregion -- end of security
 
    /***************************************************************************/
    // region   Cookie settings
    public const CookieExpiration = [
        'default' => 30 * 86400,
    ];
 
    public const ExtendedLoginCookieExpiration = [
        'default' => 180 * 86400,
    ];
 
    public const CookieDomain = [
        'default' => '',
    ];
 
    public const CookiePath = [
        'default' => '/',
    ];
 
    public const CookieSecure = [
        'default' => 'detect',
        'dynamicDefault' => [ 'use' => [ 'ForceHTTPS' ] ]
    ];
 
    public static function getDefaultCookieSecure( $forceHTTPS ): bool {
        return $forceHTTPS || ( WebRequest::detectProtocol() === 'https' );
    }
 
    public const CookiePrefix = [
        'default' => false,
        'dynamicDefault' => [
            'use' => [ 'SharedDB', 'SharedPrefix', 'SharedTables', 'DBname', 'DBprefix' ]
        ],
    ];
 
    public static function getDefaultCookiePrefix(
        $sharedDB, $sharedPrefix, $sharedTables, $dbName, $dbPrefix
    ): string {
        if ( $sharedDB && in_array( 'user', $sharedTables ) ) {
            return $sharedDB . ( $sharedPrefix ? "_$sharedPrefix" : '' );
        }
        return $dbName . ( $dbPrefix ? "_$dbPrefix" : '' );
    }
 
    public const CookieHttpOnly = [
        'default' => true,
    ];
 
    public const CookieSameSite = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const UseSameSiteLegacyCookies = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const CacheVaryCookies = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const SessionName = [
        'default' => false,
    ];
 
    public const CookieSetOnAutoblock = [
        'default' => true,
    ];
 
    public const CookieSetOnIpBlock = [
        'default' => true,
    ];
 
    // endregion -- end of cookie settings
 
    /***************************************************************************/
    // region   Profiling, testing and debugging
    // See $wgProfiler for how to enable profiling.
 
    public const DebugLogFile = [
        'default' => '',
    ];
 
    public const DebugLogPrefix = [
        'default' => '',
    ];
 
    public const DebugRedirects = [
        'default' => false,
    ];
 
    public const DebugRawPage = [
        'default' => false,
    ];
 
    public const DebugComments = [
        'default' => false,
    ];
 
    public const DebugDumpSql = [
        'default' => false,
    ];
 
    public const TrxProfilerLimits = [
        'default' => [
            // HTTP GET/HEAD requests.
            // Primary queries should not happen on GET requests
            'GET' => [
                'masterConns' => 0,
                'writes' => 0,
                'readQueryTime' => 5,
                'readQueryRows' => 10000
            ],
            // HTTP POST requests.
            // Primary reads and writes will happen for a subset of these.
            'POST' => [
                'readQueryTime' => 5,
                'writeQueryTime' => 1,
                'readQueryRows' => 100000,
                'maxAffected' => 1000
            ],
            'POST-nonwrite' => [
                'writes' => 0,
                'readQueryTime' => 5,
                'readQueryRows' => 10000
            ],
            // Deferred updates that run after HTTP response is sent for GET requests
            'PostSend-GET' => [
                'readQueryTime' => 5,
                'writeQueryTime' => 1,
                'readQueryRows' => 10000,
                'maxAffected' => 1000,
                // Log primary queries under the post-send entry point as they are discouraged
                'masterConns' => 0,
                'writes' => 0,
            ],
            // Deferred updates that run after HTTP response is sent for POST requests
            'PostSend-POST' => [
                'readQueryTime' => 5,
                'writeQueryTime' => 1,
                'readQueryRows' => 100000,
                'maxAffected' => 1000
            ],
            // Background job runner
            'JobRunner' => [
                'readQueryTime' => 30,
                'writeQueryTime' => 5,
                'readQueryRows' => 100000,
                'maxAffected' => 500 // ballpark of $wgUpdateRowsPerQuery
            ],
            // Command-line scripts
            'Maintenance' => [
                'writeQueryTime' => 5,
                'maxAffected' => 1000
            ]
        ],
        'type' => 'map',
    ];
 
    public const DebugLogGroups = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const MWLoggerDefaultSpi = [
        'default' => [ 'class' => 'MediaWiki\\Logger\\LegacySpi', ],
        'mergeStrategy' => 'replace',
        'type' => 'map',
    ];
 
    public const ShowDebug = [
        'default' => false,
    ];
 
    public const SpecialVersionShowHooks = [
        'default' => false,
    ];
 
    public const ShowExceptionDetails = [
        'default' => false,
    ];
 
    public const LogExceptionBacktrace = [
        'default' => true,
    ];
 
    public const PropagateErrors = [
        'default' => true,
    ];
 
    public const ShowHostnames = [
        'default' => false,
    ];
 
    public const OverrideHostname = [
        'default' => false,
    ];
 
    public const DevelopmentWarnings = [
        'default' => false,
    ];
 
    public const DeprecationReleaseLimit = [
        'default' => false,
    ];
 
    public const Profiler = [
        'default' => [],
        'type' => 'map',
        'mergeStrategy' => 'replace',
    ];
 
    public const StatsdServer = [
        'default' => false,
    ];
 
    public const StatsdMetricPrefix = [
        'default' => 'MediaWiki',
    ];
 
    public const StatsdSamplingRates = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const StatsTarget = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const StatsFormat = [
        'default' => null,
        'type' => '?string',
    ];
 
    public const StatsPrefix = [
        'default' => 'mediawiki',
        'type' => 'string',
    ];
 
    public const PageInfoTransclusionLimit = [
        'default' => 50,
    ];
 
    public const EnableJavaScriptTest = [
        'default' => false,
    ];
 
    public const CachePrefix = [
        'default' => false,
    ];
 
    public const DebugToolbar = [
        'default' => false,
    ];
 
    // endregion -- end of profiling, testing and debugging
 
    /***************************************************************************/
    // region   Search
    public const DisableTextSearch = [
        'default' => false,
    ];
 
    public const AdvancedSearchHighlighting = [
        'default' => false,
    ];
 
    public const SearchHighlightBoundaries = [
        'default' => '[\\p{Z}\\p{P}\\p{C}]',
    ];
 
    public const OpenSearchTemplate = [
        'default' => false,
        'deprecated' => 'since 1.25 ' .
            'Use $wgOpenSearchTemplates[\'application/x-suggestions+json\'] instead',
    ];
 
    public const OpenSearchTemplates = [
        'default' => [
            'application/x-suggestions+json' => false,
            'application/x-suggestions+xml' => false,
        ],
        'type' => 'map',
    ];
 
    public const EnableOpenSearchSuggest = [
        'default' => true,
        'obsolete' => 'Since 1.35, no longer used',
        'description' => 'Has been emitting warnings since 1.39 (LTS). ' .
            'Can be removed completely in 1.44, assuming 1.43 is an LTS release.'
    ];
 
    public const OpenSearchDefaultLimit = [
        'default' => 10,
    ];
 
    public const OpenSearchDescriptionLength = [
        'default' => 100,
    ];
 
    public const SearchSuggestCacheExpiry = [
        'default' => 1200,
    ];
 
    public const DisableSearchUpdate = [
        'default' => false,
    ];
 
    public const NamespacesToBeSearchedDefault = [
        'default' => [ NS_MAIN => true, ],
        'type' => 'map',
    ];
 
    public const DisableInternalSearch = [
        'default' => false,
    ];
 
    public const SearchForwardUrl = [
        'default' => null,
    ];
 
    public const SitemapNamespaces = [
        'default' => false,
        'type' => 'false|list',
    ];
 
    public const SitemapNamespacesPriorities = [
        'default' => false,
        'type' => 'false|map',
    ];
 
    public const EnableSearchContributorsByIP = [
        'default' => true,
    ];
 
    public const SpecialSearchFormOptions = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const SearchMatchRedirectPreference = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const SearchRunSuggestedQuery = [
        'default' => true,
        'type' => 'boolean',
    ];
 
    // endregion -- end of search settings
 
    /***************************************************************************/
    // region   Edit user interface
    public const Diff3 = [
        'default' => '/usr/bin/diff3',
    ];
 
    public const Diff = [
        'default' => '/usr/bin/diff',
    ];
 
    public const PreviewOnOpenNamespaces = [
        'default' => [
            NS_CATEGORY => true
        ],
        'type' => 'map',
    ];
 
    public const UniversalEditButton = [
        'default' => true,
    ];
 
    public const UseAutomaticEditSummaries = [
        'default' => true,
    ];
 
    // endregion -- end edit UI
 
    /***************************************************************************/
    // region   Maintenance
    // See also $wgSiteNotice
 
    public const CommandLineDarkBg = [
        'default' => false,
    ];
 
    public const ReadOnly = [
        'default' => null,
    ];
 
    public const ReadOnlyWatchedItemStore = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const ReadOnlyFile = [
        'default' => false,
        'dynamicDefault' => [ 'use' => [ 'UploadDirectory' ] ]
    ];
 
    public static function getDefaultReadOnlyFile( $uploadDirectory ): string {
        return "$uploadDirectory/lock_yBgMBwiR";
    }
 
    public const UpgradeKey = [
        'default' => false,
    ];
 
    public const GitBin = [
        'default' => '/usr/bin/git',
    ];
 
    public const GitRepositoryViewers = [
        'default' => [
            'https://(?:[a-z0-9_]+@)?gerrit.wikimedia.org/r/(?:p/)?(.*)' => 'https://gerrit.wikimedia.org/g/%R/+/%H',
            'ssh://(?:[a-z0-9_]+@)?gerrit.wikimedia.org:29418/(.*)' => 'https://gerrit.wikimedia.org/g/%R/+/%H',
        ],
        'type' => 'map',
    ];
 
    // endregion -- End of maintenance
 
    /***************************************************************************/
    // region   Recent changes, new pages, watchlist and history
    public const RCMaxAge = [
        'default' => 90 * 24 * 3600,
    ];
 
    public const WatchersMaxAge = [
        'default' => 180 * 24 * 3600,
    ];
 
    public const UnwatchedPageSecret = [
        'default' => 1,
    ];
 
    public const RCFilterByAge = [
        'default' => false,
    ];
 
    public const RCLinkLimits = [
        'default' => [ 50, 100, 250, 500 ],
        'type' => 'list',
    ];
 
    public const RCLinkDays = [
        'default' => [ 1, 3, 7, 14, 30 ],
        'type' => 'list',
    ];
 
    public const RCFeeds = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const RCEngines = [
        'default' => [
            'redis' => RedisPubSubFeedEngine::class,
            'udp' => UDPRCFeedEngine::class,
        ],
        'type' => 'map',
    ];
 
    public const RCWatchCategoryMembership = [
        'default' => false,
    ];
 
    public const UseRCPatrol = [
        'default' => true,
    ];
 
    public const StructuredChangeFiltersLiveUpdatePollingRate = [
        'default' => 3,
    ];
 
    public const UseNPPatrol = [
        'default' => true,
    ];
 
    public const UseFilePatrol = [
        'default' => true,
    ];
 
    public const Feed = [
        'default' => true,
    ];
 
    public const FeedLimit = [
        'default' => 50,
    ];
 
    public const FeedCacheTimeout = [
        'default' => 60,
    ];
 
    public const FeedDiffCutoff = [
        'default' => 32768,
    ];
 
    public const OverrideSiteFeed = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const FeedClasses = [
        'default' => [
            'rss' => \MediaWiki\Feed\RSSFeed::class,
            'atom' => \MediaWiki\Feed\AtomFeed::class,
        ],
        'type' => 'map',
    ];
 
    public const AdvertisedFeedTypes = [
        'default' => [ 'atom', ],
        'type' => 'list',
    ];
 
    public const RCShowWatchingUsers = [
        'default' => false,
    ];
 
    public const RCShowChangedSize = [
        'default' => true,
    ];
 
    public const RCChangedSizeThreshold = [
        'default' => 500,
    ];
 
    public const ShowUpdatedMarker = [
        'default' => true,
    ];
 
    public const DisableAnonTalk = [
        'default' => false,
    ];
 
    public const UseTagFilter = [
        'default' => true,
    ];
 
    public const SoftwareTags = [
        'default' => [
            'mw-contentmodelchange' => true,
            'mw-new-redirect' => true,
            'mw-removed-redirect' => true,
            'mw-changed-redirect-target' => true,
            'mw-blank' => true,
            'mw-replace' => true,
            'mw-rollback' => true,
            'mw-undo' => true,
            'mw-manual-revert' => true,
            'mw-reverted' => true,
            'mw-server-side-upload' => true,
        ],
        'type' => 'map',
        'additionalProperties' => [ 'type' => 'boolean', ],
    ];
 
    public const UnwatchedPageThreshold = [
        'default' => false,
    ];
 
    public const RecentChangesFlags = [
        'default' => [
            'newpage' => [
                'letter' => 'newpageletter',
                'title' => 'recentchanges-label-newpage',
                'legend' => 'recentchanges-legend-newpage',
                'grouping' => 'any',
            ],
            'minor' => [
                'letter' => 'minoreditletter',
                'title' => 'recentchanges-label-minor',
                'legend' => 'recentchanges-legend-minor',
                'class' => 'minoredit',
                'grouping' => 'all',
            ],
            'bot' => [
                'letter' => 'boteditletter',
                'title' => 'recentchanges-label-bot',
                'legend' => 'recentchanges-legend-bot',
                'class' => 'botedit',
                'grouping' => 'all',
            ],
            'unpatrolled' => [
                'letter' => 'unpatrolledletter',
                'title' => 'recentchanges-label-unpatrolled',
                'legend' => 'recentchanges-legend-unpatrolled',
                'grouping' => 'any',
            ],
        ],
        'type' => 'map',
    ];
 
    public const WatchlistExpiry = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const WatchlistPurgeRate = [
        'default' => 0.1,
        'type' => 'float',
    ];
 
    public const WatchlistExpiryMaxDuration = [
        'default' => '1 year',
        'type' => '?string',
    ];
 
    // endregion -- end RC/watchlist
 
    /***************************************************************************/
    // region   Copyright and credits settings
    public const RightsPage = [
        'default' => null,
    ];
 
    public const RightsUrl = [
        'default' => null,
    ];
 
    public const RightsText = [
        'default' => null,
    ];
 
    public const RightsIcon = [
        'default' => null,
    ];
 
    public const UseCopyrightUpload = [
        'default' => false,
    ];
 
    public const MaxCredits = [
        'default' => 0,
    ];
 
    public const ShowCreditsIfMax = [
        'default' => true,
    ];
 
    // endregion -- end of copyright and credits settings
 
    /***************************************************************************/
    // region   Import / Export
    public const ImportSources = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ImportTargetNamespace = [
        'default' => null,
    ];
 
    public const ExportAllowHistory = [
        'default' => true,
    ];
 
    public const ExportMaxHistory = [
        'default' => 0,
    ];
 
    public const ExportAllowListContributors = [
        'default' => false,
    ];
 
    public const ExportMaxLinkDepth = [
        'default' => 0,
    ];
 
    public const ExportFromNamespaces = [
        'default' => false,
    ];
 
    public const ExportAllowAll = [
        'default' => false,
    ];
 
    public const ExportPagelistLimit = [
        'default' => 5000,
    ];
 
    public const XmlDumpSchemaVersion = [
        'default' => XML_DUMP_SCHEMA_VERSION_11,
    ];
 
    // endregion -- end of import/export
 
    /***************************************************************************/
    // region   Wiki Farm
    public const WikiFarmSettingsDirectory = [
        'default' => null
    ];
 
    public const WikiFarmSettingsExtension = [
        'default' => 'yaml'
    ];
 
    // endregion -- End Wiki Farm
 
    /***************************************************************************/
    // region   Extensions
    public const ExtensionFunctions = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const ExtensionMessagesFiles = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const MessagesDirs = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ExtensionEntryPointListFiles = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const EnableParserLimitReporting = [
        'default' => true,
    ];
 
    public const ValidSkinNames = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const SpecialPages = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const AutoloadAttemptLowercase = [
        'default' => false,
        'obsolete' => 'Since 1.40; no longer has any effect.',
        'description' => 'Has been emitting warnings since 1.39 (LTS). ' .
            'Can be removed completely in 1.44, assuming 1.43 is an LTS release.'
    ];
 
    public const ExtensionCredits = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const Hooks = [
        'default' => [],
        'type' => 'map',
        'mergeStrategy' => 'array_merge_recursive',
    ];
 
    public const ServiceWiringFiles = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const JobClasses = [
        'default' => [
            'deletePage' => DeletePageJob::class,
            'refreshLinks' => RefreshLinksJob::class,
            'deleteLinks' => DeleteLinksJob::class,
            'htmlCacheUpdate' => HTMLCacheUpdateJob::class,
            'sendMail' => [
                'class' => EmaillingJob::class,
                'services' => [
                    0 => 'Emailer'
                ]
            ],
            'enotifNotify' => EnotifNotifyJob::class,
            'fixDoubleRedirect' => [
                'class' => DoubleRedirectJob::class,
                'services' => [
                    'RevisionLookup',
                    'MagicWordFactory',
                    'WikiPageFactory',
                ],
                // This job requires a title
                'needsPage' => true,
            ],
            'AssembleUploadChunks' => AssembleUploadChunksJob::class,
            'PublishStashedFile' => PublishStashedFileJob::class,
            'ThumbnailRender' => ThumbnailRenderJob::class,
            'recentChangesUpdate' => RecentChangesUpdateJob::class,
            'refreshLinksPrioritized' => RefreshLinksJob::class,
            'refreshLinksDynamic' => RefreshLinksJob::class,
            'activityUpdateJob' => ActivityUpdateJob::class,
            'categoryMembershipChange' => CategoryMembershipChangeJob::class,
            'clearUserWatchlist' => ClearUserWatchlistJob::class,
            'watchlistExpiry' => WatchlistExpiryJob::class,
            'cdnPurge' => CdnPurgeJob::class,
            'userGroupExpiry' => UserGroupExpiryJob::class,
            'clearWatchlistNotifications' => ClearWatchlistNotificationsJob::class,
            'userOptionsUpdate' => UserOptionsUpdateJob::class,
            'revertedTagUpdate' => RevertedTagUpdateJob::class,
            'null' => NullJob::class,
            'userEditCountInit' => UserEditCountInitJob::class,
            'parsoidCachePrewarm' => [
                'class' => ParsoidCachePrewarmJob::class,
                'services' => [
                    'ParsoidOutputAccess',
                    'PageStore',
                    'RevisionLookup'
                ],
                // tell the JobFactory not to include the $page parameter in the constructor call
                'needsPage' => false
            ],
            'renameUser' => [
                'class' => RenameUserJob::class,
                'services' => [
                    'MainConfig',
                    'DBLoadBalancerFactory'
                ]
            ],
        ],
        'type' => 'map',
    ];
 
    public const JobTypesExcludedFromDefaultQueue = [
        'default' => [ 'AssembleUploadChunks', 'PublishStashedFile' ],
        'type' => 'list',
    ];
 
    public const JobBackoffThrottling = [
        'default' => [],
        'type' => 'map',
        'additionalProperties' => [ 'type' => 'float', ],
    ];
 
    public const JobTypeConf = [
        'default' => [
            'default' => [
                'class' => JobQueueDB::class,
                'order' => 'random',
                'claimTTL' => 3600
            ],
        ],
        'additionalProperties' => [
            'type' => 'object',
            'properties' => [
                'class' => [ 'type' => 'string' ],
                'order' => [ 'type' => 'string' ],
                'claimTTL' => [ 'type' => 'int' ]
            ],
        ],
        'type' => 'map',
    ];
 
    public const JobQueueIncludeInMaxLagFactor = [
        'default' => false,
    ];
 
    public const SpecialPageCacheUpdates = [
        'default' => [
            'Statistics' => [ SiteStatsUpdate::class, 'cacheUpdate' ]
        ],
        'type' => 'map',
    ];
 
    public const PagePropLinkInvalidations = [
        'default' => [ 'hiddencat' => 'categorylinks', ],
        'type' => 'map',
    ];
 
    // endregion -- End extensions
 
    /***************************************************************************/
    // region   Categories
    public const CategoryMagicGallery = [
        'default' => true,
    ];
 
    public const CategoryPagingLimit = [
        'default' => 200,
    ];
 
    public const CategoryCollation = [
        'default' => 'uppercase',
    ];
 
    public const TempCategoryCollations = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const TrackingCategories = [
        'default' => [],
        'type' => 'list',
        'deprecated' => 'since 1.25 Extensions should now register tracking categories using ' .
            'the new extension registration system.',
    ];
 
    // endregion -- End categories
 
    /***************************************************************************/
    // region   Logging
    public const LogTypes = [
        'default' => [
            '',
            'block',
            'protect',
            'rights',
            'delete',
            'upload',
            'move',
            'import',
            'patrol',
            'merge',
            'suppress',
            'tag',
            'managetags',
            'contentmodel',
            'renameuser',
        ],
        'type' => 'list',
    ];
 
    public const LogRestrictions = [
        'default' => [ 'suppress' => 'suppressionlog', ],
        'type' => 'map',
    ];
 
    public const FilterLogTypes = [
        'default' => [
            'patrol' => true,
            'tag' => true,
            'newusers' => false,
        ],
        'type' => 'map',
    ];
 
    public const LogNames = [
        'default' => [
            '' => 'all-logs-page',
            'block' => 'blocklogpage',
            'protect' => 'protectlogpage',
            'rights' => 'rightslog',
            'delete' => 'dellogpage',
            'upload' => 'uploadlogpage',
            'move' => 'movelogpage',
            'import' => 'importlogpage',
            'patrol' => 'patrol-log-page',
            'merge' => 'mergelog',
            'suppress' => 'suppressionlog',
        ],
        'type' => 'map',
    ];
 
    public const LogHeaders = [
        'default' => [
            '' => 'alllogstext',
            'block' => 'blocklogtext',
            'delete' => 'dellogpagetext',
            'import' => 'importlogpagetext',
            'merge' => 'mergelogpagetext',
            'move' => 'movelogpagetext',
            'patrol' => 'patrol-log-header',
            'protect' => 'protectlogtext',
            'rights' => 'rightslogtext',
            'suppress' => 'suppressionlogtext',
            'upload' => 'uploadlogpagetext',
        ],
        'type' => 'map',
    ];
 
    public const LogActions = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const LogActionsHandlers = [
        'default' => [
            'block/block' => BlockLogFormatter::class,
            'block/reblock' => BlockLogFormatter::class,
            'block/unblock' => BlockLogFormatter::class,
            'contentmodel/change' => ContentModelLogFormatter::class,
            'contentmodel/new' => ContentModelLogFormatter::class,
            'delete/delete' => DeleteLogFormatter::class,
            'delete/delete_redir' => DeleteLogFormatter::class,
            'delete/delete_redir2' => DeleteLogFormatter::class,
            'delete/event' => DeleteLogFormatter::class,
            'delete/restore' => DeleteLogFormatter::class,
            'delete/revision' => DeleteLogFormatter::class,
            'import/interwiki' => ImportLogFormatter::class,
            'import/upload' => ImportLogFormatter::class,
            'managetags/activate' => LogFormatter::class,
            'managetags/create' => LogFormatter::class,
            'managetags/deactivate' => LogFormatter::class,
            'managetags/delete' => LogFormatter::class,
            'merge/merge' => MergeLogFormatter::class,
            'move/move' => MoveLogFormatter::class,
            'move/move_redir' => MoveLogFormatter::class,
            'patrol/patrol' => PatrolLogFormatter::class,
            'patrol/autopatrol' => PatrolLogFormatter::class,
            'protect/modify' => ProtectLogFormatter::class,
            'protect/move_prot' => ProtectLogFormatter::class,
            'protect/protect' => ProtectLogFormatter::class,
            'protect/unprotect' => ProtectLogFormatter::class,
            'renameuser/renameuser' => RenameuserLogFormatter::class,
            'rights/autopromote' => RightsLogFormatter::class,
            'rights/rights' => RightsLogFormatter::class,
            'suppress/block' => BlockLogFormatter::class,
            'suppress/delete' => DeleteLogFormatter::class,
            'suppress/event' => DeleteLogFormatter::class,
            'suppress/reblock' => BlockLogFormatter::class,
            'suppress/revision' => DeleteLogFormatter::class,
            'tag/update' => TagLogFormatter::class,
            'upload/overwrite' => UploadLogFormatter::class,
            'upload/revert' => UploadLogFormatter::class,
            'upload/upload' => UploadLogFormatter::class,
        ],
        'type' => 'map',
    ];
 
    public const ActionFilteredLogs = [
        'default' => [
            'block' => [
                'block' => [ 'block' ],
                'reblock' => [ 'reblock' ],
                'unblock' => [ 'unblock' ],
            ],
            'contentmodel' => [
                'change' => [ 'change' ],
                'new' => [ 'new' ],
            ],
            'delete' => [
                'delete' => [ 'delete' ],
                'delete_redir' => [ 'delete_redir', 'delete_redir2' ],
                'restore' => [ 'restore' ],
                'event' => [ 'event' ],
                'revision' => [ 'revision' ],
            ],
            'import' => [
                'interwiki' => [ 'interwiki' ],
                'upload' => [ 'upload' ],
            ],
            'managetags' => [
                'create' => [ 'create' ],
                'delete' => [ 'delete' ],
                'activate' => [ 'activate' ],
                'deactivate' => [ 'deactivate' ],
            ],
            'move' => [
                'move' => [ 'move' ],
                'move_redir' => [ 'move_redir' ],
            ],
            'newusers' => [
                'create' => [ 'create', 'newusers' ],
                'create2' => [ 'create2' ],
                'autocreate' => [ 'autocreate' ],
                'byemail' => [ 'byemail' ],
            ],
            'protect' => [
                'protect' => [ 'protect' ],
                'modify' => [ 'modify' ],
                'unprotect' => [ 'unprotect' ],
                'move_prot' => [ 'move_prot' ],
            ],
            'rights' => [
                'rights' => [ 'rights' ],
                'autopromote' => [ 'autopromote' ],
            ],
            'suppress' => [
                'event' => [ 'event' ],
                'revision' => [ 'revision' ],
                'delete' => [ 'delete' ],
                'block' => [ 'block' ],
                'reblock' => [ 'reblock' ],
            ],
            'upload' => [
                'upload' => [ 'upload' ],
                'overwrite' => [ 'overwrite' ],
                'revert' => [ 'revert' ],
            ],
        ],
        'type' => 'map',
    ];
 
    public const NewUserLog = [
        'default' => true,
    ];
 
    public const PageCreationLog = [
        'default' => true,
    ];
 
    // endregion -- end logging
 
    /***************************************************************************/
    // region   Special pages (general and miscellaneous)
    public const AllowSpecialInclusion = [
        'default' => true,
    ];
 
    public const DisableQueryPageUpdate = [
        'default' => false,
    ];
 
    public const CountCategorizedImagesAsUsed = [
        'default' => false,
    ];
 
    public const MaxRedirectLinksRetrieved = [
        'default' => 500,
    ];
 
    public const RangeContributionsCIDRLimit = [
        'default' => [
            'IPv4' => 16,
            'IPv6' => 32,
        ],
        'type' => 'map',
        'additionalProperties' => [ 'type' => 'integer', ],
    ];
 
    // endregion -- end special pages
 
    /***************************************************************************/
    // region   Actions
    public const Actions = [
        'default' => [],
        'type' => 'map',
    ];
 
    // endregion -- end actions
 
    /***************************************************************************/
    // region   Robot (search engine crawler) policy
    // See also $wgNoFollowLinks.
 
    public const DefaultRobotPolicy = [
        'default' => 'index,follow',
    ];
 
    public const NamespaceRobotPolicies = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ArticleRobotPolicies = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const ExemptFromUserRobotsControl = [
        'default' => null,
        'type' => '?list',
    ];
 
    // endregion End robot policy
 
    /***************************************************************************/
    // region   Action API and REST API
    public const DebugAPI = [
        'default' => false,
    ];
 
    public const APIModules = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const APIFormatModules = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const APIMetaModules = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const APIPropModules = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const APIListModules = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const APIMaxDBRows = [
        'default' => 5000,
    ];
 
    public const APIMaxResultSize = [
        'default' => 8388608,
    ];
 
    public const APIMaxUncachedDiffs = [
        'default' => 1,
    ];
 
    public const APIMaxLagThreshold = [
        'default' => 7,
    ];
 
    public const APIRequestLog = [
        'default' => false,
    ];
 
    public const APICacheHelpTimeout = [
        'default' => 60 * 60,
    ];
 
    public const APIUselessQueryPages = [
        'default' => [
            'MIMEsearch',
            'LinkSearch',
        ],
        'type' => 'list',
    ];
 
    public const AjaxLicensePreview = [
        'default' => true,
    ];
 
    public const CrossSiteAJAXdomains = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const CrossSiteAJAXdomainExceptions = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const AllowedCorsHeaders = [
        'default' => [
            /* simple headers (see spec) */
            'Accept',
            'Accept-Language',
            'Content-Language',
            'Content-Type',
            /* non-authorable headers in XHR, which are however requested by some UAs */
            'Accept-Encoding',
            'DNT',
            'Origin',
            /* MediaWiki whitelist */
            'User-Agent',
            'Api-User-Agent',
            /* Allowing caching preflight requests, see T269636 */
            'Access-Control-Max-Age',
            /* OAuth 2.0, see T322944 */
            'Authorization',
        ],
        'type' => 'list',
    ];
 
    public const RestAPIAdditionalRouteFiles = [
        'default' => [],
        'type' => 'list',
    ];
 
    // endregion -- End AJAX and API
 
    /***************************************************************************/
    // region   Shell and process control
    public const MaxShellMemory = [
        'default' => 307200,
    ];
 
    public const MaxShellFileSize = [
        'default' => 102400,
    ];
 
    public const MaxShellTime = [
        'default' => 180,
    ];
 
    public const MaxShellWallClockTime = [
        'default' => 180,
    ];
 
    public const ShellCgroup = [
        'default' => false,
    ];
 
    public const PhpCli = [
        'default' => '/usr/bin/php',
    ];
 
    public const ShellRestrictionMethod = [
        'default' => 'autodetect',
        'type' => 'string|false',
    ];
 
    public const ShellboxUrls = [
        'default' => [ 'default' => null, ],
        'type' => 'map',
        'additionalProperties' => [
            'type' => 'string|false|null',
        ],
    ];
 
    public const ShellboxSecretKey = [
        'default' => null,
        'type' => '?string',
    ];
 
    // endregion -- end Shell and process control
 
    /***************************************************************************/
    // region   HTTP client
    public const HTTPTimeout = [
        'default' => 25,
        'type' => 'float',
    ];
 
    public const HTTPConnectTimeout = [
        'default' => 5.0,
        'type' => 'float',
    ];
 
    public const HTTPMaxTimeout = [
        'default' => 0,
        'type' => 'float',
    ];
 
    public const HTTPMaxConnectTimeout = [
        'default' => 0,
        'type' => 'float',
    ];
 
    public const HTTPImportTimeout = [
        'default' => 25,
    ];
 
    public const AsyncHTTPTimeout = [
        'default' => 25,
    ];
 
    public const HTTPProxy = [
        'default' => '',
    ];
 
    public const LocalVirtualHosts = [
        'default' => [],
        'type' => 'map',
    ];
 
    public const LocalHTTPProxy = [
        'default' => false,
        'type' => 'string|false',
    ];
 
    public const AllowExternalReqID = [
        'default' => false,
    ];
 
    // endregion -- End HTTP client
 
    /***************************************************************************/
    // region   Job queue
    public const JobRunRate = [
        'default' => 1,
    ];
 
    public const RunJobsAsync = [
        'default' => false,
    ];
 
    public const UpdateRowsPerJob = [
        'default' => 300,
    ];
 
    public const UpdateRowsPerQuery = [
        'default' => 100,
    ];
 
    // endregion -- End job queue
 
    /***************************************************************************/
    // region   Miscellaneous
    public const RedirectOnLogin = [
        'default' => null,
    ];
 
    public const VirtualRestConfig = [
        'default' => [
            'paths' => [],
            'modules' => [],
            'global' => [
                # Timeout in seconds
                'timeout' => 360,
                # 'domain' is set to $wgCanonicalServer in Setup.php
                'forwardCookies' => false,
                'HTTPProxy' => null
            ]
        ],
        'mergeStrategy' => 'array_plus_2d',
        'type' => 'map',
    ];
 
    public const EventRelayerConfig = [
        'default' => [
            'default' => [ 'class' => EventRelayerNull::class, ],
        ],
        'type' => 'map',
    ];
 
    public const Pingback = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const OriginTrials = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const ReportToExpiry = [
        'default' => 86400,
        'type' => 'integer',
    ];
 
    public const ReportToEndpoints = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const FeaturePolicyReportOnly = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const SkinsPreferred = [
        'default' => [ 'vector-2022', 'vector' ],
        'type' => 'list',
    ];
 
    public const SpecialContributeSkinsEnabled = [
        'default' => [],
        'type' => 'list',
    ];
 
    public const EnableEditRecovery = [
        'default' => false,
        'type' => 'boolean',
    ];
 
    public const EditRecoveryExpiry = [
        'default' => 2592000,
        'type' => 'integer',
    ];
 
    // endregion -- End Miscellaneous
 
}