Add a set of properties that need to be injected

@param array<string, mixed> $properties
192610
public function withProperties(array $properties): self
    {
        $map = $this->properties;

        foreach ($properties as $key => $value) {
            $map = $map->put($key, $value);
        }

        return new self(
            $this->class,
            $map,
            $this->injectionStrategy,
            $this->instanciator
        );
    }
1161316
public function injectSettings(array $settings) {
		if (isset($settings['client']['serviceBaseUri'])) {
			$this->clientServiceBaseUri = $settings['client']['serviceBaseUri'];
		}
		if (isset($settings['client']['publicKeyFingerprint'])) {
			$this->clientPublicKeyFingerprint = $settings['client']['publicKeyFingerprint'];
		}
	}
494208
protected function setProperties(array $properties = [])
    {
        foreach ($properties as $name => $value) {
            // set property
            if (property_exists($this, $name)) {
                $this->$name = $value;

            // unknown property found
            } else {
                trigger_error(
                    sprintf(
                        'unknown property "%s" for "%s"',
                        $name,
                        get_class($this)
                    ),
                    E_USER_WARNING
                );
            }
        }
    }
330425
protected function dereferenceProperty(...$properties)
    {
        foreach ((array)$properties as $property) {
            if (!property_exists($this, $property)) {
                continue; // @codeCoverageIgnore
            }
            
            $value = $this->$property;
            unset($this->$property);
            $this->$property = $value;
        }
    }
644106
public static function makePublicProperties(array $properties)
    {
        echo '<pre>'."\n";

        foreach ($properties as $key => $value)
        {
            $type = gettype($value);

            if ($type === 'object') {
                $type = get_class($value);
            }

            echo <<<EODOC
    /**
     * @var $type
     */
    public \$$key;

EODOC;
        }

        echo '</pre>'."\n";
    }
600694
public function setUnsigned(array $properties)
    {
        $this->isUnsigned = (Helpers::isKeyExists($properties, 'is-unsigned') && $properties['is-unsigned'])
        || in_array($this->getEloquentDataMethod(), $this->unsignedTypes);

        return $this;
    }
333314
private function setType(array &$properties)
    {
        $type = array_pull($properties, 'type', null);

        $this->type = is_null($type)
            ? $this->guessType($properties)
            : $type;

        return $this;
    }
748349
public function initialize(array $properties = null)
    {
        $attributes = [];
        $embedOne = [];
        $embedMany = [];

        if (null !== $properties) {
            $attributes = $this->applyDefaultAttrValues($attributes);
            foreach ($properties as $key => $value) {
                if (true === $this->isAttribute($key)) {
                    // Load attribute.
                    $attributes[$key] = $this->convertAttributeValue($key, $value);
                } else if (true === $this->isEmbedHasOne($key) && is_array($value)) {
                    // Load embed one.
                    $embedOne[$key] = $this->getStore()->loadEmbed($this->getMetadata()->getEmbed($key)->embedMeta, $value);
                }
            }
        }

        foreach ($this->getMetadata()->getEmbeds() as $key => $embeddedPropMeta) {
            // Always load embedded collections, regardless if data is set.
            if (true === $embeddedPropMeta->isOne()) {
                continue;
            }
            $embeds = !isset($properties[$key]) ? [] : $properties[$key];
            $embedMany[$key] = $this->getStore()->createEmbedCollection($embeddedPropMeta, $embeds);
        }

        $this->attributes    = (null === $this->attributes) ? new Attributes($attributes) : $this->attributes->replace($attributes);
        $this->hasOneEmbeds  = (null === $this->hasOneEmbeds) ? new Embeds\HasOne($embedOne) : $this->hasOneEmbeds->replace($embedOne);
        $this->hasManyEmbeds = (null === $this->hasManyEmbeds) ? new Embeds\HasMany($embedMany) : $this->hasManyEmbeds->replace($embedMany);

        if (true === $this->getState()->is('new')) {
            // Ensure default values are applied to new models.
            $this->apply([]);
        }

        $this->doDirtyCheck();
        return $this;
    }
358548
public function configure($properties = array())
    {
        foreach ($properties as $name => $value) {
            if ( ! property_exists($this, $name)) {
                throw new PropertyDoesNotExist(sprintf('Property "%s" does not exist in %s', $name,
                    get_called_class()));
            }
            $this->{$name} = $value;
        }
    }
819632
public function addProperty($property)
    {
        $properties = $this->getProperties();
        array_push($properties, $property);
        $this->setProperties($properties);
    }
304816
public function setObserved(array $properties)
    {
        foreach ($properties as $property) {
            if (!$property instanceof Property) {
                throw new InvalidArgumentException("Each observed property needs to be an instance of Property");
            }
        }
        $this->validatePropertyPaths((string) $this->className, $this->idDefinition, $properties);
        $this->observedProperties = array_unique($properties);
    }
1154351
public function fill(array $properties)
    {
        foreach ($properties as $key => $value)
        {
            $this->setAttribute($key, $value);
        }

        return $this;
    }
1091748
public static function setPropertiesValues($object, array $propertiesValues)
    {
        /*
         * No properties?
         * Nothing to do
         */
        if (empty($propertiesValues)) {
            return;
        }

        foreach ($propertiesValues as $property => $value) {
            static::setPropertyValue($object, $property, $value);
        }
    }
1201724
public function setPropertiesAsArray($properties)
    {
        if (\is_array($properties)) {
            if (\array_key_exists('id', $properties)) {
                unset($properties['id']);
            }

            foreach ($properties as $propertyName => $value) {
                $this->setProperty($propertyName, $value);
            }
        }
    }
346856
protected function setLabelsProperty(array $properties)
    {
        $labels = $this->getLabelsFromProperties($properties);

        foreach ($labels as $label) {
            $this->addLabel($label->text, $label->isPlain, $label->lang);
        }

        return $this;
    }
105234
public function setProperties(array $properties) : DataSet
    {
        $this->properties = [];

        foreach ($properties as $key => $value) {
            $this->addProperty($key, $value);
        }

        return $this;
    }
1349309
public function fromRaw($properties)
	{
		$this->validateProperties($properties);

		foreach ($properties as $property => $value) {
			$this->properties[$property] = $value;
		}
	}