Use this method with your IDE to help manually build a Chunk with PHP
@param string $name
@return Chunk
423736
public function getBlendableChunk($name)
    {
        /** @var \LCI\Blend\Blendable\Chunk $chunk */
        $chunk = new Chunk($this->modx, $this->blender, $name);
        return $chunk->setSeedsDir($this->blender->getSeedsDir());
    }
66475
public function withoutHeader($name): self
    {
        $this->assertHeaderName($name);

        $clone = clone $this;
        $clone->headers->remove($name);

        return $clone;
    }
1289243
public static function create($name)
    {
        $logger = new Logger($name);

        $localLogConfig = config('logger.local_log');
        if($localLogConfig['enabled'] && !in_array($name, $localLogConfig['exclude_names'])) {
            $streamHandler = self::streamHandler($name);
            $logger->pushHandler($streamHandler);
        }

        $logstashConfig = config('logger.logstash');
        if($logstashConfig['enabled'] && !in_array($name, $logstashConfig['exclude_names'])){
            $gelfHandler = self::logStashHandler($logstashConfig);
            $logger->pushHandler($gelfHandler);
        }

        $requestId = Request::header('x-request-id');
        $logger->setRequestId($requestId);

        return $logger;
    }
337369
public function create( $name )
	{
		$sheet = $this->_container->createSheet();
		$sheet->setTitle( $name );

		return new MW_Container_Content_PHPExcel( $sheet, $name, $this->_getOptions() );
	}
891070
public function withSkip(string $name): self
    {
        $clone = clone $this;

        if (array_key_exists($name, $clone->skips)) {
            $clone->skips[$name] = 1;
        }

        return $clone;
    }
896271
public static function create($name)
    {
        if (!isset(self::$_pool[$name])) {
            $classname = self::__getClassName($name);
            $path = self::__getDriverPath($name);

            if (!is_file($path)) {
                $errMsg = __('Could not find extension %s at location %s.', array(
                    '<code>' . $name . '</code>',
                    '<code>' . str_replace(DOCROOT . '/', '', $path) . '</code>'
                ));
                try {
                    Symphony::Engine()->throwCustomError(
                        $errMsg,
                        __('Symphony Extension Missing Error'),
                        Page::HTTP_STATUS_ERROR,
                        'missing_extension',
                        array(
                            'name' => $name,
                            'path' => $path
                        )
                    );
                } catch (Exception $ex) {
                    throw new Exception($errMsg, 0, $ex);
                }
            }

            if (!class_exists($classname)) {
                require_once($path);
            }

            // Create the extension object
            self::$_pool[$name] = new $classname(array());
        }

        return self::$_pool[$name];
    }
854215
public function createNode($name)
    {
        $node = new \PAGI\Node\Node();
        return $node->setName($name)->setAgiClient($this);
    }
162981
public function helper($name) {
		if (isset($this->_helpers[$name])) {
			return $this->_helpers[$name];
		}
		list($plugin, $helperClassName) = pluginSplit($name, true);
		$helperClassName = Inflector::camelize($helperClassName) . "ShellHelper";
		App::uses($helperClassName, $plugin . "Console/Helper");
		if (!class_exists($helperClassName)) {
			throw new RuntimeException("Class " . $helperClassName . " not found");
		}
		$helper = new $helperClassName($this->stdout);
		$this->_helpers[$name] = $helper;

		return $helper;
	}
1074666
private function createNode($name)
    {
        $treeBuilder = new TreeBuilder($name);
        if (\method_exists($treeBuilder, 'getRootNode')) {
            $rootNode = $treeBuilder->getRootNode();
        } else {
            $rootNode = $treeBuilder->root($name);
        }

        return $rootNode;
    }
1302776
protected function buildClass($name = null)
    {
        $stub = $this->files->get($this->getStub());
        return $this->replacePivotTableName($stub)
            ->replaceSchema($stub)
            ->replaceClass($stub, $name);
    }
348645
public static function create($name) {
    if (is_string($name)) {
      $name = NameNode::create($name);
    }
    /** @var ConstantNode $node */
    $node = new static();
    $node->addChild($name, 'constantName');
    return $node;
  }
278188
public function create(string $name)
    {
        $className = $this->getClassName($name);

        $result = $this->createInstance($className);

        return $result;
    }
1041554
public function chunk($size)
    {
        $chunks = array_chunk($this->all(), $size);

        $chunks = array_map(function ($chunk) {
            return new static($chunk);
        }, $chunks);

        return $chunks;
    }
1373109
public function export(string $name)
    {
        $url = self::$base_url.'/'.$name.'/get';

        return self::$curl->get($url);
    }
1245674
public function withoutHeader($name)
    {
        $instance = clone $this;
        $instance->headers->remove($name, $value);
        return $instance;
    }
1205020
public function withoutHeader($name)
    {
        $headers = $this->initHeaders();
        
        if (!$headers->hasHeader($name)) {
            return $this;
        }
        
        $clone = $this->copy();
        $clone->headers = $headers->withoutHeader($name);

        return $clone;
    }
1353740
protected function createChunkFile($name, $uuid = null, $mimeType = null)
    {
        return $this->chunkFileFactory->create(
            $name, $this->chunkPath(), $this->storagePath(), $uuid, $mimeType
        );
    }