expand example

$clone->client = $this->client->withOptions($options);

        return $clone;
    }

    /** * @return \Closure(string $url, array $vars): string */
    private function createExpanderFromPopularVendors(): \Closure
    {
        if (class_exists(\GuzzleHttp\UriTemplate\UriTemplate::class)) {
            return \GuzzleHttp\UriTemplate\UriTemplate::expand(...);
        }

        if (class_exists(\League\Uri\UriTemplate::class)) {
            return static fn (string $url, array $vars): string => (new \League\Uri\UriTemplate($url))->expand($vars);
        }

        if (class_exists(\Rize\UriTemplate::class)) {
            return (new \Rize\UriTemplate())->expand(...);
        }

        throw new \LogicException('Support for URI template requires a vendor to expand the URI. Run "composer require guzzlehttp/uri-template" or pass your own expander \Closure implementation.');
    }

')) { $first = mb_strstr($key, '.', true); $rest = mb_strstr($key, '.'); // occurrence of dot is checked in if clause, so `mb_strstr` can't return false and the assert should not cause an exception
                \assert(\is_string($rest));

                if (isset($result[$first])) {
                    $result[$first] = array_merge_recursive($result[$first], self::expand([mb_substr($rest, 1) => $value]));
                } else {
                    $result[$first] = self::expand([mb_substr($rest, 1) => $value]);
                }
            } else {
                $result[$key] = $value;
            }
        }

        return $result;
    }
}

  public static function createFromQueryParameter($parameter, ResourceType $resource_type, FieldResolver $field_resolver) {
    $expanded = static::expand($parameter);
    foreach ($expanded as &$filter_item) {
      if (isset($filter_item[static::CONDITION_KEY][EntityCondition::PATH_KEY])) {
        $unresolved = $filter_item[static::CONDITION_KEY][EntityCondition::PATH_KEY];
        $operator = $filter_item[static::CONDITION_KEY][EntityCondition::OPERATOR_KEY];
        $filter_item[static::CONDITION_KEY][EntityCondition::PATH_KEY] = $field_resolver->resolveInternalEntityQueryPath($resource_type, $unresolved, $operator);
      }
    }
    return new static(static::buildEntityConditionGroup($expanded));
  }

  /** * Expands any filter parameters using shorthand notation. * * @param array $original * The unexpanded filter data. * * @return array * The expanded filter data. */

static::assertSame($flattened, ArrayNormalizer::flatten($nested));
    }

    /** * @dataProvider provideTestData * * @param array<string, mixed> $nested * @param array<string, string> $flattened */
    public function testExpanding(array $nested, array $flattened): void
    {
        static::assertSame($nested, ArrayNormalizer::expand($flattened));
    }

    /** * @return array<mixed>[][] */
    public static function provideTestData(): array
    {
        return [
            [
                [ // nested                     'firstName' => 'Foo',
                    

        foreach ($this->mapping as $m) {
            $sorted[$m->getMappedKey()] = $mapped[$m->getMappedKey()] ?? '';
        }

        if (empty($sorted)) {
            return;
        }

        if (!$this->flatten) {
            $sorted = ArrayNormalizer::expand($sorted);
        }

        yield from $sorted;
    }

    /** * @param iterable<string, mixed> $record * * @return iterable<string, mixed> */
    public function out(Config $config, iterable $record): iterable
    {

            if (!$localizable) {
                $trans .= $text;

                continue;
            }

            $this->addAccents($trans, $text);
        }

        $this->expand($trans, $visibleText);

        $this->addBrackets($trans);

        return $trans;
    }

    public function getLocale(): string
    {
        return $this->translator->getLocale();
    }