Un-register a decorator class

@param string $configKey
170553
public function unregisterDecorator($configKey)
    {
        if (!isset($this->decorators[$configKey])) {
            throw new \RuntimeException('Decorator key not registered: ' . $configKey);
        }
        unset($this->decorators[$configKey]);
    }
1251612
public static function unregisterInstance(): void
    {
        if (!self::$unregistering && self::$client !== null) {
            self::$unregistering = true;

            if ((self::$client->preparedToSendBuffer ?: '') !== '') {
                self::$client->sendBuffer .= self::$client->preparedToSendBuffer;
            }

            try {
                self::$client->sendBuffer .= self::$client->protocol->getKeepAlive();
                self::$client->protocol->flush();
            } catch (\Throwable $e) {
            }

            // TODO MUST TEST, IT WAS REMOVED FROM FUNCTION
            // BECAUSE IT SIMPLY LOOKS LIKE THE LINES BEFORE
            // ADDED AN IF TO CHECK THE CHANNEL In CASE OF
            //
            if (isset(self::$client->protocol->handler->channel) &&
                false === strpos(get_class(self::getClient()->protocol->handler->channel), '/EmptyChannel/')) {
                try {
                    self::$client->protocol->keepAlive();
                } catch (\Throwable $e) {
                    // silently discard exceptions when unregistering
                }
            }

            self::$client = null;
            self::$instance = null;
            self::$instanceOptionsKey = null;
            self::$unregistering = false;
        }
    }
618523
public function offsetUnset($key)
	{
		if (isset($this->jar[$key]))
		{
			$this->jar[$key]->delete();
		}
		elseif ($this->parentEnabled)
		{
			$this->parent->delete($key);
		}
	}
1033547
public function offsetUnset($key)
    {
        $this->checkKey($this->key_type, $key);
        unset($this->container[$key]);
    }
413015
public static function remove($pKey)
    {
        if (! array_key_exists($pKey, self::$_registry)) {
            throw new Exception("The registry key '$pKey' doesn't exist");
        }

        if (is_object(self::$_registry[$pKey]) and method_exists(self::$_registry[$pKey], '__destruct')) {
            self::$_registry[$pKey]->__destruct();
        }

        unset(self::$_registry[$pKey]);

        return true;
    }
221521
public static function unregisterFatal()
    {
        Pool::createPool();

        // Disabled?
        if (static::$pool->config->getSetting(Fallback::SETTING_DISABLED) ||
            Config::$disabledByPhp
        ) {
            return;
        }

        static::$pool->createClass('Brainworxx\\Krexx\\Controller\\ErrorController')
            ->unregisterFatalAction();
    }
671027
protected function removeAdditionalConfiguration($extensionKey)
	{
		$newLines = $this->getCleanAdditionalConfiguration($extensionKey);

		if (empty($newLines) !== true)
		{
			$this->getConfigurationManager()->writeAdditionalConfiguration($newLines);

			/**
			 * Add Flashmessage that the configuration has written
			 */
			$flashMessage = GeneralUtility::makeInstance(
				'TYPO3\\CMS\\Core\\Messaging\\FlashMessage',
				'Configuration successfully removed from ' .
				$this->getConfigurationManager()->getAdditionalConfigurationFileLocation() .
				'.',
				'Configuration removed',
				FlashMessage::OK,
				true
			);
			$this->addFlashMessage($flashMessage);
		}
		else
		{
			unlink($this->getConfigurationManager()->getAdditionalConfigurationFileLocation());

			/**
			 * Add Flashmessage that the configuration has deleted
			 */
			$flashMessage = GeneralUtility::makeInstance(
				'TYPO3\\CMS\\Core\\Messaging\\FlashMessage',
				'File ' .
				$this->getConfigurationManager()->getAdditionalConfigurationFileLocation() .
				' successfully deleted.',
				'Configuration delete',
				FlashMessage::OK,
				true
			);
			$this->addFlashMessage($flashMessage);
		}
	}
171206
public function clean(string $key = null): ConfigInterface
    {
        if (null !== $key) {
            unset($this->_config[$key]);
        } else {
            $this->_config = [];
        }

        return $this;
    }
1155036
public static function close($config_name)
    {
        if (isset(self::$instance[$config_name])) {
            self::$instance[$config_name]->closeConnection();
            self::$instance[$config_name] = null;
        }
    }
1181855
protected function _configDelete($key)
    {
        if (strpos($key, '.') === false) {
            unset($this->_config[$key]);

            return;
        }

        $update =& $this->_config;
        $stack = explode('.', $key);
        $length = count($stack);

        foreach ($stack as $i => $k) {
            if (!is_array($update)) {
                throw new Exception(sprintf('Cannot unset %s value', $key));
            }

            if (!isset($update[$k])) {
                break;
            }

            if ($i === $length - 1) {
                unset($update[$k]);
                break;
            }

            $update =& $update[$k];
        }
    }
409336
public static function delete( $key ) {

		if ( isset( self::$config[ strtolower( $key ) ] ) ) {
			unset( self::$config[ strtolower( $key ) ] );
		}

	}
842332
public function remove($key)
    {
        $method = 'remove'.$key;

        if (method_exists($this, $method)) {
            $this->$method();
        } else {
            unset($this->metas[$key]);
        }
    }
53786
public function getConfig(string $configKey): APIConfig
    {
        if ($this->hasConfig($configKey)) {
            return $this->configs[$configKey];
        }

        throw ConfigException::noConfig($configKey);
    }
707526
public function removeHooks( $key )
	{
		if ( array_key_exists( $key, $this->hooks ) )
		{
			unset( $this->hooks[$key] );
			$this->bakeTriggers();
		}
	}
1179507
public function offsetUnset($key)
    {
        $keys = $this->parseKey($key);
        $array = &$this->values;

        while (count($keys) > 1) {
            $key = array_shift($keys);

            if (!isset($array[$key]) || !is_array($array[$key])) {
                return;
            }

            $array =& $array[$key];
        }

        unset($array[array_shift($keys)]);
    }
81184
function purge( $key ) {
            $this->_logger->entrance( 'key = ' . $key );

            $this->_options->unset_option( $key, true );
        }
1130582
public function getConfigStruct(string $configKey): ConfigStruct
    {
        if (!$this->hasConfigStruct($configKey)) {
            throw ConfigException::noConfigStruct($configKey);
        }

        return $this->configStructs[$configKey];
    }