Supported processing types can be given as processing prototypes or a list of type classes

@param Prototype[]|array $processingTypes
@return ProcessingTypes
964674
public static function support(array $processingTypes)
    {
        $prototypes = [];

        foreach ($processingTypes as $typeClassOrPrototype) {
            if ($typeClassOrPrototype instanceof Prototype) {
                $prototypes[] = $typeClassOrPrototype;
            } else {
                Assertion::string($typeClassOrPrototype);
                Assertion::classExists($typeClassOrPrototype);
                Assertion::implementsInterface($typeClassOrPrototype, Type::class);
                $prototypes[] = $typeClassOrPrototype::prototype();
            }
        }

        return new self($prototypes, false);
    }
806794
private function getMessageProcessor($processorServiceId)
    {
        $processor = $this->container->get($processorServiceId);
        if (!$processor instanceof MessageProcessorInterface) {
            throw new \LogicException(sprintf(
                'Invalid message processor service given. It must be an instance of %s but %s',
                MessageProcessorInterface::class,
                get_class($processor)
            ));
        }

        return $processor;
    }
886171
public function setRequiredTypes(array $types)
    {
        $this->required = array_merge($this->required, $types);
        $this->requiredTypes = $types;

        return $this;
    }
1070361
private function addProcessors(array $processors)
    {
        // We need to reverse the array because Monolog "pushes" processors to top of the stack
        foreach (array_reverse($processors) as $processor) {
            $this->logger->pushProcessor($processor);
        }
    }
305274
public function having($conditions, $params = array(), $types = array())
    {
        $conditions = $this->processCondition($conditions, $params, $types);
        return $this->add('having', $conditions);
    }
1225923
public function types()
    {
        if (is_null($this->typeRequests)) {
            $this->typeRequests = new TypeRequests($this->client);
        }

        return $this->typeRequests;
    }
917655
public java.util.List<ProcessType> getProcesses() {
        if (processes == null) {
            processes = new com.amazonaws.internal.SdkInternalList<ProcessType>();
        }
        return processes;
    }
23212
public function setProcessors(array $processors)
    {
        $this->processors = [];

        foreach ($processors as $processor) {
            $this->addProcessor($processor);
        }

        return $this;
    }
610886
public function addProcessor($callback, $processBufferRecord = false)
    {
        if (!is_callable($callback) && !$this->isInstanceOf($callback, ProcessorInterface::class)) {
            throw new \InvalidArgumentException('Processor must be valid callable or an instance of ' . ProcessorInterface::class);
        }

        if ($processBufferRecord) {
            $this->bufferProcessors->prepend($callback);
        } else {
            $this->processors->prepend($callback);
        }


        return $this;
    }
15059
protected function removeImpossibleArraySubtypes(array $types): array
    {
        $subTypes = $this->getSubTypes();

        if (count($subTypes) === 0) {
            return $types;
        }

        $subHandler = $this->setTypes($subTypes);

        foreach ($this->value as $item) {
            $subHandler = $subHandler->setTypes($subHandler->getPossibleTypes($item));
        }

        $possibleSubTypes = $subHandler->types;

        return count($possibleSubTypes) === count($subTypes)
            ? $types
            : array_filter($types, function($type) use ($possibleSubTypes) {
                return substr($type, -2) !== '[]' || in_array(substr($type, 0, -2), $possibleSubTypes);
            });
    }
267855
public function process($processors = null)
    {
        if ($processors === null) { // Use the default and registered processors.
            $processors = self::processors();
        }
        if (is_array($processors) === false && is_callable($processors)) {
            $processors = [$processors];
        }
        foreach ($processors as $processor) {
            $processor($this);
        }
    }
143379
private function sanitizePostProcessors(array $processors): array
    {
        $sanitized = array_filter($processors, function (string $name): bool {
            return isset($this->postProcessors[$name]);
        }, ARRAY_FILTER_USE_KEY);

        if (\count($processors) !== \count($sanitized)) {
            throw new \InvalidArgumentException(sprintf('Could not find post processor(s): %s', implode(', ', array_map(function (string $name): string {
                return sprintf('"%s"', $name);
            }, array_diff(array_keys($processors), array_keys($sanitized))))));
        }

        return $sanitized;
    }
70500
public function getProcessorType()
    {
        $int = $this->variant->processorType();

        $possible = [
            1 => 'Other',
            2 => 'Unknown',
            3 => 'Central Processor',
            4 => 'Math Processor',
            5 => 'DSP Processor',
            6 => 'Video Processor',
        ];

        return $this->getFromPossibleValues($int, $possible);
    }
370289
public function acceptable(array $supportedMimeTypes): self
    {
        if (count($supportedMimeTypes) > 0) {
            $this->add('X-Acceptable', join(', ', $supportedMimeTypes));
        }

        return $this;
    }
1325460
private function loadFixableTypes(?array $returnTypes): array
    {
        return array_filter($returnTypes ?? [], function (string $returnType): bool {
            return $this->isFixableReturnType($returnType);
        });
    }
1177580
public function setProcessingDate($ts)
    {
        if ($ts === null) {
            $this->processingDate = null;
            return $this;
        }

        if (is_string($ts)) {
            try {
                $ts = new DateTime($ts);
            } catch (Exception $e) {
                throw new InvalidArgumentException(
                    sprintf('%s (%s)', $e->getMessage(), $ts)
                );
            }
        }

        if (!($ts instanceof DateTimeInterface)) {
            throw new InvalidArgumentException(
                'Invalid "Processing Date" value. Must be a date/time string or a DateTime object.'
            );
        }

        $this->processingDate = $ts;

        return $this;
    }
332747
private function replaceStaticType(array $types, string $staticType): array
    {
        $mixins = array_merge(
            [Model::class],
            $this->mixins->getMixinsFromClass($this->broker, $this->broker->getClass(Model::class))
        );

        foreach ($types as $key => $type) {
            if ($type instanceof ObjectType && in_array($type->getClassName(), $mixins, true)) {
                $types[$key] = new StaticType($staticType);
            }

            if ($type instanceof StaticType) {
                $types[$key] = new StaticType($staticType);
            }

            if ($type instanceof IterableType) {
                $types[$key] = $type->changeBaseClass($staticType);
            }

            if ($type instanceof IntersectionType) {
                $types[$key] = new IntersectionType($this->replaceStaticType($type->getTypes(), $staticType));
            }
        }

        return $types;
    }