Internal method to get the default config
@return array
@uses getTypes()
761631
protected function getDefaultConfig()
    {
        $defaultConfig = [
            'denyExtensionRename' => true,
            'denyUpdateCheck' => true,
            'dirnameChangeChars' => [' ' => '_', ':' => '_'],
            'disabled' => false,
            'filenameChangeChars' => [' ' => '_', ':' => '_'],
            'jpegQuality' => 100,
            'uploadDir' => UPLOADED,
            'uploadURL' => Router::url('/files', true),
            'types' => $this->getTypes(),
        ];

        //If the user is not and admin
        if (!$this->Auth->isGroup(['admin'])) {
            //Only admins can delete or rename directories
            $defaultConfig['access']['dirs'] = [
                'create' => true,
                'delete' => false,
                'rename' => false,
            ];
            //Only admins can delete, move or rename files
            $defaultConfig['access']['files'] = [
                'upload' => true,
                'delete' => false,
                'copy' => true,
                'move' => false,
                'rename' => false,
            ];
        }

        return $defaultConfig;
    }
190029
public function getCustomStylesConfig()
    {
        $styles = [];
        
        if (($config = $this->owner->config()->custom_styles) && is_array($config)) {
            $styles = $config;
        }
        
        ksort($styles);
        
        array_walk($styles, function (&$item) {
            $item = $this->owner->cleanStyleClasses($item);
        });
        
        return $styles;
    }
333543
public static function getDefaultSettings()
    {
        return array(
            // Application
            'mode' => 'development',
            // Debugging
            'debug' => true,
            // Logging
            'log.writer' => null,
            'log.level' => \Yee\Log::DEBUG,
            'log.enabled' => true,
            // View
            'templates.path' => './templates',
            'view' => '\Yee\View',
            // Cookies
            'cookies.encrypt' => false,
            'cookies.lifetime' => '20 minutes',
            'cookies.path' => '/',
            'cookies.domain' => null,
            'cookies.secure' => false,
            'cookies.httponly' => false,
            // Encryption
            'cookies.secret_key' => 'CHANGE_ME',
            'cookies.cipher' => MCRYPT_RIJNDAEL_256,
            'cookies.cipher_mode' => MCRYPT_MODE_CBC,
            // HTTP
            'http.version' => '1.1',
            // Routing
            'routes.case_sensitive' => true
        );
    }
887407
protected static function getConfig()
    {
        if (static::$config) {
            return static::$config;
        }

        $config = Registry::get('config');
        if (!isset($config['log'])) {
            throw new ConfigException('log config not exists');
        }
        $config = $config['log'];

        if (!isset($config['level'])) {
            $config['level'] = 'info';
        }
        $config['level'] = isset(static::$logLevels[$config['level']])
            ? static::$logLevels[$config['level']]
            : Logger::INFO;

        if (!isset($config['channel'])) {
            $config['channel'] = static::$defaultChannel;
        }

        return static::$config = $config;
    }
794222
public function getDefaultValuesForProperties()
    {
        $this->initialize();
        if (!isset($this->fullConfiguration['properties'])) {
            return [];
        }

        $defaultValues = [];
        foreach ($this->fullConfiguration['properties'] as $propertyName => $propertyConfiguration) {
            if (isset($propertyConfiguration['defaultValue'])) {
                $type = isset($propertyConfiguration['type']) ? $propertyConfiguration['type'] : '';
                switch ($type) {
                    case 'DateTime':
                        $defaultValues[$propertyName] = new \DateTime($propertyConfiguration['defaultValue']);
                    break;
                    default:
                        $defaultValues[$propertyName] = $propertyConfiguration['defaultValue'];
                }
            }
        }

        return $defaultValues;
    }
511399
public function getType() : ?string 
    {
        if ( ! $this->hasType()) {
            $this->setType($this->getDefaultType());
        }
        return $this->type;
    }
524552
private static function getConfig() {

        if(!isset(self::$config)) {

            $default = Format::jsonToArray(File::get('../config/default.config.json'));
            $custom = Format::jsonToArray(File::get('../config/custom.config.json'));

            if ($default && $custom) {

                self::$config = self::merge($default, $custom);
            } else if ($default) {

                self::$config = $default;
            }
        }

        if(isset(self::$config)) {

            return self::$config;
        }        

        return false;
    }
658768
public function getDefaultOptions(): array
    {
        $options = parent::getDefaultOptions();

        // Check the "type" attribute. If it is not set,
        // let's define it by default to "submit".
        if (! isset($options['attributes']['type'])) {
            $options['attributes']['type'] = 'submit';
        }

        // By default, disable button field type to be mapped
        // to a data object.
        $options['mapped'] = false;

        return $options;
    }
648184
public function xTypeConfig()
    {
        $class = get_class($this);

        if (!isset(_XTypeTraitStorage::$typeCache[$class])) {
            $config = isset($this->xType) ? $this->xType : [];
            _XTypeTraitStorage::$typeCache[$class] = $this->bootXTypeConfig($config);
        }

        return _XTypeTraitStorage::$typeCache[$class];

    }
1330402
public function getDefault() {
		if ( empty( $this->config['repositories'] ) ) {
			return false;
		}

		$config = array_values( $this->config['repositories'] );

		return $config[0]['repository'];
	}
357226
public function getTypes()
    {
        $types = $this->config()->get('types');
        $i18nTypes = [];
        $allowedTypes = $this->config()->get('allowed_types');

        if ($this->allowed_types_override) {
            // Prioritise local field over global settings
            $allowedTypes = $this->allowed_types_override;
        }

        if ($allowedTypes) {
            foreach ($allowedTypes as $type) {
                if (!array_key_exists($type, $types)) {
                    user_error("{$type} is not a valid link type");
                }
            }

            foreach (array_diff_key($types, array_flip($allowedTypes)) as $key => $value) {
                unset($types[$key]);
            }
        }

        // Get translatable labels
        foreach ($types as $key => $label) {
            $i18nTypes[$key] = _t('Linkable.TYPE' . strtoupper($key), $label);
        }

        return $i18nTypes;
    }
349750
public function getDefault() {
		if( is_object($this->default) ) {
			$this->default = call_user_func_array($this->default->type, (array) $this->default->args);
		} else
		if( defined($this->default) ) {
			return constant($this->default);
		}
		return $this->default;
	}
606365
public function defaults()
    {
        $defaults = $this->config;
        if (!isset($defaults['width'])) {
            $defaults['width'] = $defaults['default_width'];
        }
        if (!isset($defaults['height'])) {
            $defaults['height'] = $defaults['default_height'];
        }
        return $defaults;
    }
445068
private function getDefaultProviders()
    {
        $defaultProviders = array();

        foreach ($this->defaultProviders as $provider) {
            $defaultProviders[$provider] = $this->getProvider($provider);
        }

        return $defaultProviders;
    }
549521
protected function getConfig(){
    $config = array();

    $config['zipMaxSize'] = 'default';
    if (isset($GLOBALS['config']['ZipMaxSize']) && (string)$GLOBALS['config']['ZipMaxSize']!='default' ){
      $config['zipMaxSize'] = CKFinder_Connector_Utils_Misc::returnBytes((string)$GLOBALS['config']['ZipMaxSize']);
    }

    return $config;
  }
1225379
protected function getDefaultParameters()
    {
        $defaultParameters = array('--no-debug' => true);

        if ($this->input->hasOption('env')) {
            $defaultParameters['--env'] = $this->input->hasOption('env') ? $this->input->getOption('env') : 'dev';
        }

        if ($this->input->hasOption('no-interaction') && true === $this->input->getOption('no-interaction')) {
            $defaultParameters['--no-interaction'] = true;
        }

        if ($this->input->hasOption('verbose') && true === $this->input->getOption('verbose')) {
            $defaultParameters['--verbose'] = true;
        }

        return $defaultParameters;
    }
68203
public function getConfig()
    {
        $config = array(
            'label' => $this->getI18nLabel(),
            'icon' => $this->getIcon(),
            'buttonClasses' => $this->getButtonClasses(),
            'xhr' => $this->getXhr(),
            'destructive' => $this->getDestructive()
        );
        return $config;
    }