Phpro SOAP-client

https://github.com/phpro/soap-client
Admin
Phpro SOAP-client is a general-purpose PHP library designed to simplify SOAP integrations by...
Tokens:92,803
Snippets:600
Trust Score:7.2
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Run the SOAP client scaffolding wizard

Source: https://github.com/phpro/soap-client/blob/v6.x/README.md

Run the scaffolding wizard to generate a SOAP client setup. This command guides you through creating the necessary files and configurations.

```sh
./vendor/bin/soap-client wizard
```

--------------------------------

### Install a PSR-6 cache implementation

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

V4 requires a psr/cache-implementation. This example installs symfony/cache, but other cache adapters are also acceptable.

```bash
composer require symfony/cache
```

--------------------------------

### Install PSR-18 HTTP client and PSR-7/PSR-17 implementations

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Install a PSR-18 HTTP client and PSR-7/PSR-17 implementations required by the package. This example uses symfony/http-client and nyholm/psr7.

```bash
composer require symfony/http-client nyholm/psr7
```

--------------------------------

### Install phpro/soap-client with Composer

Source: https://github.com/phpro/soap-client/blob/v6.x/README.md

Install the phpro/soap-client package via Composer. Run this command in your project root to add the library as a dependency.

```sh
$ composer require phpro/soap-client
```

--------------------------------

### Advanced client factory example

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/cli/generate-clientfactory.md

This PHP example shows a more advanced client factory that can be customized. It uses various components like Psr18Transport, FlatteningLoader, RedisAdapter, and EventDispatchingCaller. The factory returns a client instance and can be tweaked to fit your needs.

```php
<?php

use Http\Client\Common\PluginClient;
use Http\Discovery\Psr18ClientDiscovery;
use Phpro\SoapClient\Caller\EngineCaller;
use Phpro\SoapClient\Caller\EventDispatchingCaller;
use Phpro\SoapClient\Soap\EngineOptions;
use Phpro\SoapClient\Soap\DefaultEngineFactory;
use Phpro\SoapClient\Soap\Metadata\Manipulators\DuplicateTypes\IntersectDuplicateTypesStrategy;
use Phpro\SoapClient\Soap\Metadata\MetadataOptions;
use Soap\CachedEngine\CacheConfig;
use Soap\Encoding\EncoderRegistry;
use Soap\Psr18Transport\Psr18Transport;
use Soap\Psr18Transport\Wsdl\Psr18Loader;
use Soap\Wsdl\Loader\FlatteningLoader;
use Soap\WsdlReader\Locator\ServiceSelectionCriteria
use Soap\WsdlReader\Model\Definitions\SoapVersion;
use Symfony\Component\Cache\Adapter\RedisAdapter;
use Symfony\Component\EventDispatcher\EventDispatcher;

class CalculatorClientFactory
{
    public static function factory(string $wsdl): CalculatorClient
    {
        $engine = DefaultEngineFactory::create(
            EngineOptions::defaults($wsdl)
                ->withEncoderRegistry(
                    EncoderRegistry::default()
                        ->addClassMapCollection(CalculatorClassmap::getCollection())
                )
                ->withTransport(
                    Psr18Transport::createForClient(
                        new PluginClient(
                            Psr18ClientDiscovery::find(),
                            [$plugin1, $plugin2]
                        )
                    )    
                )
                ->withWsdlLoader(
                    new FlatteningLoader(
                        new Psr18Loader(Psr18ClientDiscovery::find())
                    )
                )
                ->withCache(
                    new RedisAdapter(RedisAdapter::createConnection('redis://localhost')),
                    new CacheConfig('my-wsdl-cache-key', ttlInSeconds: 3600)
                )
                ->withWsdlServiceSelectionCriteria(
                    ServiceSelectionCriteria::defaults()
                        ->withPreferredSoapVersion(SoapVersion::SOAP_12)
                        ->withServiceName('SpecificServiceName')
                        ->withPortName('SpecificPortName')
                )
        );

        $eventDispatcher = new EventDispatcher();
        $caller = new EventDispatchingCaller(new EngineCaller($engine), $eventDispatcher);

        return new CalculatorClient($caller);
    }
}

```

--------------------------------

### Install recommended HTTP client and PSR-7 implementation

Source: https://github.com/phpro/soap-client/blob/v6.x/README.md

Use this composer command to install the recommended HTTP client (symfony/http-client) and PSR-7 implementation (nyholm/psr7) as required by the package's prerequisites.

```sh
$ composer require symfony/http-client nyholm/psr7
```

--------------------------------

### InterfaceAssembler example output

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Adds a specific interface to the generated class. The example shows a class implementing Iterator with no methods.

```php

use Iterator;

class MyType implements Iterator
{


}

```

--------------------------------

### SetterAssembler configuration

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Example of configuring SetterAssembler to disable doc blocks while enabling type hints.

```php
new SetterAssembler((new SetterAssemblerOptions())->withDocBlocks(false)->withTypeHints())
```

--------------------------------

### Example generated class map output

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/cli/generate-classmap.md

Example output of a generated class map. It shows a PHP class with a static method returning a ClassMapCollection containing ClassMap instances for each type mapping.

```php
<?php

namespace Myapp\Example\Classmap;

use Soap\Encoding\ClassMap\ClassMapCollection;
use Soap\Encoding\ClassMap\ClassMap;

class OrderClassMap
{

    public static function getCollection(): ClassMapCollection
    {
        return new ClassMapCollection(
            new ClassMap('http://namespace', 'CreateOrder', Type\Example1::class),
            new ClassMap('http://namespace', 'CardOrder', Type\Example2::class),
            new ClassMap('http://namespace', 'OrderDetails', Type\Example3::class)
        );
    }
}
```

--------------------------------

### Require PSR-3 Log Implementation

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/event-subscribers/logger.md

Install any PSR-3 Log implementation using Composer.

```bash
composer require psr/log-implementation
```

--------------------------------

### Migrate SOAP client configuration from v4 to v5

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Migration example showing the v4 configuration using removed methods (setTypeDestination, setTypeNamespace, setClientName, etc.) and the v5 equivalent using new value objects (Destination, ClientConfig, ClassMapConfig, TypeNamespaceMap). The v5 version replaces the old string-based setters with dedicated value objects.

```php
use Phpro\SoapClient\CodeGenerator\Config\Config;

return Config::create()
    ->setEngine($engine = DefaultEngineFactory::create(
        EngineOptions::defaults('your.wsdl')
    ))
    ->setTypeDestination('src/Type')
    ->setTypeNamespace('App\\Type')
    ->setClientName('MyClient')
    ->setClientNamespace('App')
    ->setClientDestination('src')
    ->setClassMapName('MyClassmap')
    ->setClassMapNamespace('App')
    ->setClassMapDestination('src');
```

```php
use Phpro\SoapClient\CodeGenerator\Config\ClassMapConfig;
use Phpro\SoapClient\CodeGenerator\Config\ClientConfig;
use Phpro\SoapClient\CodeGenerator\Config\Config;
use Phpro\SoapClient\CodeGenerator\Config\Destination;
use Phpro\SoapClient\CodeGenerator\Config\TypeNamespaceMap;

return Config::create()
    ->setEngine($engine = DefaultEngineFactory::create(
        EngineOptions::defaults('your.wsdl')
    ))
    ->setTypeNamespaceMap(
        TypeNamespaceMap::create(new Destination('src/Type', 'App\\Type'))
    )
    ->setClient(new ClientConfig('MyClient', new Destination('src', 'App')))
    ->setClassMap(new ClassMapConfig('MyClassmap', new Destination('src', 'App')));
```

--------------------------------

### Configure engine in code generation configuration

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

In V4, the engine factory changed. Use DefaultEngineFactory::create() with EngineOptions::defaults() and a WSDL loader. This example shows a FlatteningLoader with a StreamWrapperLoader, but a PSR-18 based loader is also possible.

```php
use Phpro\SoapClient\CodeGenerator\Config\Config;
use Phpro\SoapClient\Soap\CodeGeneratorEngineFactory;
use Phpro\SoapClient\Soap\DefaultEngineFactory;
use Phpro\SoapClient\Soap\EngineOptions;
use Soap\Wsdl\Loader\FlatteningLoader;
use Soap\Wsdl\Loader\StreamWrapperLoader;

return Config::create()
    ->setEngine($engine = DefaultEngineFactory::create(
        EngineOptions::defaults('your.wsdl')
            ->withWsdlLoader(new FlatteningLoader(new StreamWrapperLoader())) // Or a PSR18-based loader ... :))
    ))
```

--------------------------------

### Customize generated value-objects with interfaces

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/cli/generate-types.md

Example of customizing generated value-objects by implementing required interfaces. Shows how to add constructors and methods to the generated classes.

```php
class HelloWorldRequest implements RequestInterface
{
    public function __construct($name) {
        $this->name = $name
    }

    // Generated code
}

class HelloWorldResponse implements ResponseProviderInterface
{
    // Generated code
    
    public function getResponse()
    {
        return $this->greeting;
    }
}

class Greeting implements ResponseInterface
{
    // Generated code
    
    public function getGreeting()
    {
        return $this->greeting;
    }
}

```

--------------------------------

### DefaultValuesStrategy All Mode Example

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Uses DefaultValuesStrategy::All to give all scalar parameters type-appropriate defaults ('' for string, 0 for int) and nullable parameters = null. Parameters with defaults are reordered to the end.

```php
// All scalars get defaults:
new ConstructorAssembler((new ConstructorAssemblerOptions())->withTypeHints()->withDefaultValues(DefaultValuesStrategy::All))
```

```php
    public function __construct(SomeClass $obj, string $prop1 = '', int $prop2 = 0)
    {
        $this->obj = $obj;
        $this->prop1 = $prop1;
        $this->prop2 = $prop2;
    }
```

--------------------------------

### DefaultValuesStrategy OptionalOnly Example

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Default DefaultValuesStrategy::OptionalOnly mode: only WSDL-optional/nullable parameters get = null, and parameters with defaults are reordered to the end. The example shows a nullable Contact parameter with a default.

```php
use Phpro\SoapClient\CodeGenerator\Config\DefaultValuesStrategy;

// Default (OptionalOnly) — only nullable params get = null:
new ConstructorAssembler((new ConstructorAssemblerOptions())->withTypeHints())
```

```php
    public function __construct(string $name, SomeClass $obj, ?Contact $contact = null)
    {
        $this->name = $name;
        $this->obj = $obj;
        $this->contact = $contact;
    }
```

--------------------------------

### Implement CodingStandardsStrategyInterface for custom naming

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/coding-standards.md

Defines a custom strategy by implementing all required methods: normalizeTypeName, normalizeOperationName, normalizeNamespaceSegment, normalizeEnumCaseName, generatePropertyAccessorMethodName, and normalizeParameterName. The example prefixes type names with 'Soap' and uses ucfirst/lcfirst for other segments.

```php
use Phpro\SoapClient\CodeGenerator\CodingStandards\CodingStandardsStrategyInterface;

class MyCodingStandards implements CodingStandardsStrategyInterface
{
    public function normalizeTypeName(string $name): string
    {
        // e.g. prefix all types
        return 'Soap' . ucfirst($name);
    }

    public function normalizeOperationName(string $method): string
    {
        return lcfirst($method);
    }

    public function normalizeNamespaceSegment(string $segment): ?string
    {
        return ucfirst($segment);
    }

    public function normalizeEnumCaseName(string $value): string
    {
        return strtoupper($value);
    }

    public function generatePropertyAccessorMethodName(string $prefix, string $property): string
    {
        return $prefix . ucfirst($property);
    }

    public function normalizeParameterName(string $propertyName): string
    {
        return lcfirst($propertyName);
    }
}

```

--------------------------------

### PropertyAssembler with DefaultValuesStrategy::All

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Applies type-appropriate defaults to all scalar properties ('' , 0, false, 0.0, []), nullable types get = null, and non-nullable complex types get no default. This uses the All strategy.

```php
use Phpro\SoapClient\CodeGenerator\Config\DefaultValuesStrategy;

// All scalars get defaults:
new PropertyAssembler(PropertyAssemblerOptions::create()->withDefaultValues(DefaultValuesStrategy::All))
```

--------------------------------

### Personalize DefaultEngineFactory with transport and metadata options

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Full example of personalizing the DefaultEngineFactory with a custom transport (Psr18Transport with PluginClient), a permanent WSDL loader provider using Md5Strategy, and metadata options that remove duplicate types. Requires a PSR-18 HTTP client and middleware variables.

```php
use Http\Client\Common\PluginClient;
use Http\Discovery\Psr18ClientDiscovery;
use Phpro\SoapClient\Soap\DefaultEngineFactory;
use Phpro\SoapClient\Soap\Metadata\Manipulators\DuplicateTypes\RemoveDuplicateTypesStrategy;
use Phpro\SoapClient\Soap\Metadata\Manipulators\TypesManipulatorChain;
use Phpro\SoapClient\Soap\Metadata\MetadataOptions;
use Soap\ExtSoapEngine\ExtSoapOptions;
use Soap\ExtSoapEngine\Wsdl\Naming\Md5Strategy;
use Soap\ExtSoapEngine\Wsdl\PermanentWsdlLoaderProvider;
use Soap\Psr18Transport\Psr18Transport;
use Soap\Psr18Transport\Wsdl\Psr18Loader;

$httpClient = Psr18ClientDiscovery::find();
$engine = DefaultEngineFactory::create(
    ExtSoapOptions::defaults($wsdl, [])
        ->withClassMap(CalculatorClassmap::getCollection())
        ->withWsdlProvider(
            new PermanentWsdlLoaderProvider(
                Psr18Loader::createForClient($httpClient),
                new Md5Strategy(),
                'target/location'
            )
        ),
    Psr18Transport::createForClient(
        new PluginClient(
            $httpClient,
            [
                $middleware1,                        
                $middleware2,                        
            ]
        )
    ),
    MetadataOptions::empty()->withTypesManipulator(
        new TypesManipulatorChain(
            new RemoveDuplicateTypesStrategy()
        )
    )
);
```

--------------------------------

### AssemblerRule: Apply GetterAssembler

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/rules.md

Creates a rule that always applies an assembler in the right context, adding code during every code generation command. In this example, a getter is created for every property in the SOAP type.

```php
use Phpro\SoapClient\CodeGenerator\Assembler;
use Phpro\SoapClient\CodeGenerator\Rules;

$rule = Rules\AssembleRule(new Assembler\GetterAssembler($someGetterOptions))
```

--------------------------------

### MultiRule with Getter and Setter Assemblers

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/rules.md

Defines multiple rules to apply on a SOAP type, useful with TypeMapRule or TypenameMatchesRule to run multiple assemblers with one regex. In this example, getters and setters are added for every property.

```php
use Phpro\SoapClient\CodeGenerator\Assembler;
use Phpro\SoapClient\CodeGenerator\Rules;

$rule = new Rules\MultiRule([
    new Rules\AssembleRule(new Assembler\GetterAssembler($someGetterOptions)),
    new Rules\AssembleRule(new Assembler\SetterAssembler()),
]);
```

--------------------------------

### Configure type replacements in client configuration

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/drivers/metadata.md

Shows how to add a custom type replacer to the default set in the client configuration. The `MyDateReplacer` is an example that replaces the XSD 'date' type with an 'int' type.

```php
use Phpro\SoapClient\CodeGenerator\Config\Config;
use Phpro\SoapClient\Soap\Metadata\Manipulators\TypeReplacer\TypeReplacers;

return Config::create()
    //...
    ->setTypeReplacements(
        TypeReplacers::defaults()
            ->add(new MyDateReplacer())
    )
    // ...
```

--------------------------------

### TraitAssembler output

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Adds a specific trait to the generated class. An alias can be passed as second argument. The example shows the trait usage in the class.

```php

use MyTrait;

class MyType
{

    use MyTrait

}
```

--------------------------------

### IteratorAssembler example output

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Makes SOAP types that contain a list of another SOAP type iterable. The generated class implements IteratorAggregate and returns an ArrayIterator over the prop1 property.

```php

use IteratorAggregate;

class MyType implements IteratorAggregate
{

    /**
     * @return \ArrayIterator
     */
    public function getIterator()
    {
        return new \ArrayIterator(is_array($this->prop1) ? $this->prop1 : []);
    }


}

```

--------------------------------

### JsonSerializableAssembler example output

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Enables JSON serialization of SOAP objects, useful for logging smaller JSON serialized request/response data. The generated class implements JsonSerializable and returns an array of properties.

```php

use JsonSerializable;

class MyType implements JsonSerializable
{

    /**
     * @return array
     */
    public function jsonSerialize()
    {
        return [
            'prop1' => \$this->prop1,
            'prop2' => \$this->prop2,
        ];
    }
}

```

--------------------------------

### UseAssembler output

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Adds usage statements to the generated class, often used internally for interfaces or traits. An alias can be passed as second argument. The example shows a use statement with alias.

```php

use MyTrait as TraitAlias;

class MyType
{


}
```

--------------------------------

### Change engine in generated ClientFactory

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

In V4, update the engine inside your generated ClientFactory. This example shows the new DefaultEngineFactory::create() call with EngineOptions::defaults(), including commented-out options for WSDL caching, alternate HTTP settings, and SOAP settings.

```php
$engine = DefaultEngineFactory::create(
    EngineOptions::defaults($wsdl)
        ->withEncoderRegistry(
            EncoderRegistry::default()
                ->addClassMapCollection(CalcClassmap::types())
                ->addBackedEnumClassMapCollection(CalcClassmap::enums())
        )
        // If you want to enable WSDL caching:
        // ->withCache($yourPsr6CachePool)
        // If you want to use Alternate HTTP settings:
        // ->withWsdlLoader()
        // ->withTransport()
        // If you want specific SOAP setting:
        // ->withWsdlParserContext()
        // ->withWsdlServiceSelectionCriteria()
);
```

--------------------------------

### Generated client using Caller injection

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Example of a generated SOAP client class that uses the Caller to transport requests. The client constructor requires a Caller instance, and the add method invokes the caller with the operation name and parameters. This replaces the previous base client approach.

```php
use Calculator\Type\Add;
use Calculator\Type\AddResponse;
use Phpro\SoapClient\Caller\Caller;

class CalculatorClient
{
    /**
     * @var Caller
     */
    private $caller;

    public function __construct(\Phpro\SoapClient\Caller\Caller $caller)
    {
        $this->caller = $caller;
    }

    public function add(Add $parameters): AddResponse
    {
        return ($this->caller)('Add', $parameters);
    }
}
```

--------------------------------

### Generate a SOAP client with type hints

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/cli/generate-client.md

Run the `generate:client` command to generate a client based on the client settings in the configuration. The client will contain all methods used to initiate calls and uses type hinted parameters and return types. A configuration file is required to build the classmap.

```sh
$ ./vendor/bin/soap-client generate:client                                                                                                                                    [16:13:31]
Usage:
  generate:client [options]

Options:
      --config=CONFIG   The location of the soap code-generator config file

```

--------------------------------

### Generate client factory command

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/cli/generate-clientfactory.md

Run this command to generate a base client factory. The factory is placed in the same namespace and directory as the client, with the client name appended by 'Factory'. A configuration file is required via the --config option.

```bash
vendor/bin/soap-client generate:clientfactory

Usage:
  generate:clientfactory [options]

Options:
      --config=CONFIG   The location of the soap code-generator config file
  -h, --help            Display this help message
  -q, --quiet           Do not output any message
  -V, --version         Display this application version
      --ansi            Force ANSI output
      --no-ansi         Disable ANSI output
  -n, --no-interaction  Do not ask any interactive question
  -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

```

--------------------------------

### Combining explicit mappings and strategies

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Demonstrates how to combine explicit withMapping() entries with a strategy, where explicit mappings take precedence.

```php
TypeNamespaceMap::create(new Destination('src/Type', 'App\\Type'))
    ->withMapping('http://special.example.com', new Destination('src/Type/Special', 'App\\Type\\Special'))
    ->withStrategy(new PrefixBasedTypeNamespaceStrategy($config->getCodingStandards()))
```

--------------------------------

### php-vcr configuration with setCassettePath and enableLibraryHooks

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/testing.md

Configures php-vcr to store cassettes in test/fixtures/vcr and enables only the soap and curl library hooks. Call turnOn() to activate recording.

```php
\VCR\VCR::configure()
    ->setCassettePath('test/fixtures/vcr')
    ->enableLibraryHooks(['soap', 'curl'])
;
\VCR\VCR::turnOn();
```

--------------------------------

### Basic SOAP client usage with generated factory

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/usage.md

Initializes the client via the generated factory and calls a method with a value-object. The response is a ResultInterface that provides getGreeting().

```php
$client = MyclientFactory::factory($wsdl = 'http://path.to/your.wsdl');
$response = $client->helloWorld(new HelloWorldRequest('name'));
echo $response->getGreeting();
```

--------------------------------

### StrictTypesAssembler output

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Adds declare(strict_types=1); to each generated file. The example shows the resulting PHP header.

```php
<?php

declare(strict_types=1);
```

--------------------------------

### Create CalculatorClientFactory with EventDispatchingCaller

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Shows how to create a SOAP client factory that injects an EventDispatchingCaller wrapping an EngineCaller, enabling the new Caller system. The engine is built with DefaultEngineFactory and ExtSoapOptions with a class map.

```php
use Symfony\Component\EventDispatcher\EventDispatcher;
use Phpro\SoapClient\Soap\DefaultEngineFactory;
use Soap\ExtSoapEngine\ExtSoapOptions;
use Phpro\SoapClient\Caller\EventDispatchingCaller;
use Phpro\SoapClient\Caller\EngineCaller;

class CalculatorClientFactory
{
    public static function factory(string $wsdl): CalculatorClient
    {
        $engine = DefaultEngineFactory::create(
            ExtSoapOptions::defaults($wsdl, [])
                ->withClassMap(CalculatorClassmap::getCollection())
        );

        $eventDispatcher = new EventDispatcher();
        $caller = new EventDispatchingCaller(new EngineCaller($engine), $eventDispatcher);

        return new CalculatorClient($caller);
    }
}
```

--------------------------------

### Regenerate all classes after upgrade

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Run these four commands to regenerate the client, classmap, types, and client factory after upgrading. The generated code may change due to namespace-aware type generation, so validate your implementation.

```bash
./vendor/bin/soap-client generate:client --config=config/soap-client.php
./vendor/bin/soap-client generate:classmap --config=config/soap-client.php
./vendor/bin/soap-client generate:types --config=config/soap-client.php
./vendor/bin/soap-client generate:clientfactory --config=config/soap-client.php
```

--------------------------------

### Run generate:config to regenerate configuration

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Run the interactive config generator to regenerate the configuration file with detected XML namespaces as commented-out withMapping() and withStrategy() suggestions.

```bash
./vendor/bin/soap-client generate:config --config=config/soap-client.php
```

--------------------------------

### Configure duplicate type strategy

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

If you use a non-default metadata strategy, configure it in the code generation configuration. This example sets a RemoveDuplicateTypesStrategy for duplicate type intersection.

```php
use Phpro\SoapClient\CodeGenerator\Config\Config;
use Phpro\SoapClient\Soap\Metadata\Manipulators\DuplicateTypes\RemoveDuplicateTypesStrategy;

return Config::create()
    ->setDuplicateTypeIntersectStrategy(
        new RemoveDuplicateTypesStrategy()
    )
```

--------------------------------

### Configure coding standards with Config::setCodingStandards()

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/coding-standards.md

Shows the generated config pattern using return ($config = Config::create()) so $config can be referenced in nested calls. Pass the coding standards to PrefixBasedTypeNamespaceStrategy so namespace segments are normalized with the same strategy.

```php
use Phpro\SoapClient\CodeGenerator\Config\Config;
use Phpro\SoapClient\CodeGenerator\Config\Destination;
use Phpro\SoapClient\CodeGenerator\Config\TypeNamespaceMap;
use Phpro\SoapClient\CodeGenerator\TypeNamespaceMap\Strategy\PrefixBasedTypeNamespaceStrategy;

return ($config = Config::create())
    ->setCodingStandards(new MyCodingStandards())
    ->setEngine(...)
    ->setTypeNamespaceMap(
        TypeNamespaceMap::create(new Destination('src/Type', 'App\Type'))
            ->withStrategy(new PrefixBasedTypeNamespaceStrategy($config->getCodingStandards()))
    )
    ->setClient(...)
    ->setClassMap(...)
;
```

--------------------------------

### Regenerate SOAP client classes

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Run these three commands to regenerate the client, classmap, and types using the updated configuration file. Execute them in the project root after updating the configuration.

```bash
./vendor/bin/soap-client generate:client --config=config/soap-client.php
```

```bash
./vendor/bin/soap-client generate:classmap --config=config/soap-client.php
```

```bash
./vendor/bin/soap-client generate:types --config=config/soap-client.php
```

--------------------------------

### GetterAssembler default getter output

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Default output of GetterAssembler: a getter method with a doc block. For boolean types, the 'is' prefix can be used instead of 'get' by enabling it in the constructor.

```php
    /**
     * @return string
     */
    public function getProp1()
    {
        return $this->prop1;
    }
```

--------------------------------

### Restore old default values behavior on PropertyAssembler

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Restores the old behavior where all scalar properties get zero-value defaults by using PropertyAssemblerOptions::create()->withDefaultValues(DefaultValuesStrategy::All).

```php
new PropertyAssembler(PropertyAssemblerOptions::create()->withDefaultValues(DefaultValuesStrategy::All))
```

--------------------------------

### CLI command to generate classmap

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/cli/generate-classmap.md

Run this command to generate a class map. It requires a configuration file specified with --config. The output shows the available options for the command.

```sh
$ ./vendor/bin/soap-client generate:classmap                                                                                                                                    [16:13:31]
Usage:
  generate:classmap [options]

Options:
      --config=CONFIG   The location of the soap code-generator config file
  -h, --help            Display this help message
  -q, --quiet           Do not output any message
  -V, --version         Display this application version
      --ansi            Force ANSI output
      --no-ansi         Disable ANSI output
  -n, --no-interaction  Do not ask any interactive question
  -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug



```

--------------------------------

### Upgrade phpro/soap-client to v2.0

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Upgrade the soap-client package to version 2.0 using Composer.

```bash
composer require phpro/soap-client:^2.0
```

--------------------------------

### Replace type with third-party class

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/drivers/metadata.md

Shows a `GuidTypeReplacer` that replaces the 'guid' type from the Microsoft namespace with a fully qualified class name. This replacer is only used for code generation; you must still implement conversion logic in a custom SOAP encoder.

```php
use Phpro\SoapClient\Soap\Metadata\Manipulators\TypeReplacer\TypeReplacer;
use Soap\Engine\Metadata\Model\XsdType;
use Soap\WsdlReader\Metadata\Predicate\IsOfType;

class GuidTypeReplacer implements TypeReplacer
{
    public function __invoke(XsdType $xsdType): XsdType
    {
        $check = new IsOfType('http://microsoft.com/wsdl/types/', 'guid');
        if (!$check($xsdType)) {
            return $xsdType;
        }

        return $xsdType->copy(\Ramsey\Uuid\UuidInterface::class);
    }
}
```

--------------------------------

### Enable Type Hints with ConstructorAssemblerOptions

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Enables type hints by passing ConstructorAssemblerOptions with withTypeHints() set to true. The generated constructor includes scalar type declarations for each property.

```php
new ConstructorAssembler((new ConstructorAssemblerOptions())->withTypeHints())
```

```php
    /**
     * Constructor
     *
     * @var string $prop1
     * @var int $prop2
     */
    public function __construct(string $prop1, int $prop2)
    {
        $this->prop1 = $prop1;
        $this->prop2 = $prop2;
    }
```

--------------------------------

### Set default values strategy on ConstructorAssemblerOptions

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Shows how to set the default values strategy on ConstructorAssemblerOptions. The three strategies are OptionalOnly (new default), All (previous default), and None.

```php
use Phpro\SoapClient\CodeGenerator\Config\DefaultValuesStrategy;

(new ConstructorAssemblerOptions())->withDefaultValues(DefaultValuesStrategy::OptionalOnly)
(new ConstructorAssemblerOptions())->withDefaultValues(DefaultValuesStrategy::All)
(new ConstructorAssemblerOptions())->withDefaultValues(DefaultValuesStrategy::None)
```

--------------------------------

### ClientMethodMatchesRule: Remove demoSetup Method

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/rules.md

Uses a regular expression to match method names in the generated Client. When the pattern matches and the subRule is accepted, the defined assembler runs. Here, a custom RemoveClientMethodAssembler removes the demoSetup method from the Client.

```php
use My\Project\CodeGenerator\Assembler as CustomAssembler;
use Phpro\SoapClient\CodeGenerator\Rules;

new Rules\ClientMethodMatchesRule(
    new Rules\AssembleRule(new CustomAssembler\RemoveClientMethodAssembler()),
    '/demoSetup$/'
)
```

--------------------------------

### Enable LocalAndGlobal enumeration generation strategy

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/configuration.md

Opts into generating PHP enums for local XSD enumerations as well as global ones. By default only global enumerations are generated to avoid naming conflicts. This setting dynamically adds extra type replacements and type manipulations to the metadata before code generation starts.

```php
use Phpro\SoapClient\CodeGenerator\Config\Config;
use Phpro\SoapClient\CodeGenerator\Config\EnumerationGenerationStrategy;

Config::create()
    ->setEnumerationGenerationStrategy(EnumerationGenerationStrategy::LocalAndGlobal);
```

--------------------------------

### FluentSetterAssembler with options and type-hinted output

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

FluentSetterAssembler configured with FluentSetterAssemblerOptions to disable doc blocks and enable type hints. The output setter uses a string type hint and omits the doc block.

```php
new FluentSetterAssembler((new FluentSetterAssemblerOptions())->withDocBlocks(false)->withTypeHints())
```

```php
    /**
     * @param string $prop1
     * @return $this
     */
    public function setProp1(string $prop1)
    {
        $this->prop1 = $prop1;
        return $this;
    }
```

--------------------------------

### Engine configuration with DefaultEngineFactory

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/configuration.md

Configures the SOAP engine for code generation. Uses DefaultEngineFactory with EngineOptions, a flattening WSDL loader, and an encoder registry. Comments show optional settings for WSDL caching, HTTP transport, and SOAP-specific options.

```php
use Phpro\SoapClient\Soap\EngineOptions;
use Phpro\SoapClient\Soap\DefaultEngineFactory;

DefaultEngineFactory::create(
    EngineOptions::defaults($wsdl)
        ->withWsdlLoader(new FlatteningLoader(new StreamWrapperLoader()))
        ->withEncoderRegistry(
            EncoderRegistry::default()
                ->addClassMapCollection(SomeClassmap::types())
                ->addBackedEnumClassMapCollection(SomeClassmap::enums())
        )
        // If you want to enable WSDL caching:
        // ->withCache() 
        // If you want to use Alternate HTTP settings:
        // ->withWsdlLoader()
        // ->withTransport()
        // If you want specific SOAP setting:
        // ->withWsdlParserContext()
        // ->withWsdlServiceSelectionCriteria()
);
```

--------------------------------

### Full SOAP client code generation configuration

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/configuration.md

Complete configuration file for the SOAP client code generator. It sets the engine, type namespace map, client, class map, and generation rules. The engine uses a flattening WSDL loader and an encoder registry with class maps. Rules define how getters, immutable setters, requests, results, extending types, and abstract types are assembled.

```php
<?php
// my-soap-config.php

use Phpro\SoapClient\CodeGenerator\Assembler;
use Phpro\SoapClient\CodeGenerator\Rules;
use Phpro\SoapClient\CodeGenerator\Config\ClassMapConfig;
use Phpro\SoapClient\CodeGenerator\Config\ClientConfig;
use Phpro\SoapClient\CodeGenerator\Config\Config;
use Phpro\SoapClient\CodeGenerator\Config\Destination;
use Phpro\SoapClient\CodeGenerator\Config\TypeNamespaceMap;
use Phpro\SoapClient\CodeGenerator\TypeNamespaceMap\Strategy\PrefixBasedTypeNamespaceStrategy;
use Phpro\SoapClient\Soap\EngineOptions;
use Phpro\SoapClient\Soap\DefaultEngineFactory;

return ($config = Config::create())
    ->setEngine(DefaultEngineFactory::create(
        EngineOptions::defaults($wsdl)
            ->withWsdlLoader(new FlatteningLoader(new StreamWrapperLoader()))
            ->withEncoderRegistry(
                EncoderRegistry::default()
                    ->addClassMapCollection(SomeClassmap::types())
                    ->addBackedEnumClassMapCollection(SomeClassmap::enums())
            )
    ))
    ->setTypeNamespaceMap(
        TypeNamespaceMap::create(new Destination('SoapTypes', 'src/SoapTypes'))
            // You can add explicit XML xmlns -> PHP namespace mappings here:
            ->withMapping('http://www.xmlns.mapping', new Destination('src/Type/OtherDir', 'App\\Type\\OtherDir'))
            // Or use a strategy to automatically resolve destinations from xmlns prefixes:
            // This strategy will only be called for XML namespaces that don't have an explicit mapping configured.
            ->withStrategy(new PrefixBasedTypeNamespaceStrategy($config->getCodingStandards()))
    )
    ->setClient(new ClientConfig('MySoapClient', new Destination('SoapClient', 'src/SoapClient')))
    ->setClassMap(new ClassMapConfig('AcmeClassmap', new Destination('Acme\\Classmap', 'src/acme/classmap')))
    ->addRule(new Rules\AssembleRule(new Assembler\GetterAssembler(new Assembler\GetterAssemblerOptions())))
    ->addRule(new Rules\AssembleRule(new Assembler\ImmutableSetterAssembler(
        new Assembler\ImmutableSetterAssemblerOptions()
    )))
    ->addRule(
        new Rules\IsRequestRule(
            $engine->getMetadata(),
            new Rules\MultiRule([
                new Rules\AssembleRule(new Assembler\RequestAssembler()),
                new Rules\AssembleRule(new Assembler\ConstructorAssembler(new Assembler\ConstructorAssemblerOptions())),
            ])
        )
    )
    ->addRule(
        new Rules\IsResultRule(
            $engine->getMetadata(),
            new Rules\MultiRule([
                new Rules\AssembleRule(new Assembler\ResultAssembler()),
            ])
        )
    )
    ->addRule(
        new Rules\IsExtendingTypeRule(
            $engine->getMetadata(),
            new Rules\AssembleRule(new Assembler\ExtendingTypeAssembler())
        )
    )
    ->addRule(
        new Rules\IsAbstractTypeRule(
            $engine->getMetadata(),
            new Rules\AssembleRule(new Assembler\AbstractClassAssembler())
        )
    )
;
```

--------------------------------

### GetterAssembler with options

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

GetterAssembler configured with GetterAssemblerOptions to disable doc blocks and enable type hints. This is normally used in conjunction with withTypeHints.

```php
new GetterAssembler((new GetterAssemblerOptions())->withDocBlocks(false)->withTypeHints())
```

--------------------------------

### Implement AssemblerInterface

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Defines the contract for a custom assembler. Implement `canAssemble` to decide whether the assembler applies to a given context, and `assemble` to generate code. Throws `AssemblerException` on failure.

```php
/**
 * Interface AssemblerInterface
 *
 * @package Phpro\SoapClient\CodeGenerator\Assembler
 */
interface AssemblerInterface
{

    /**
     * @param ContextInterface $context
     *
     * @return bool
     */
    public function canAssemble(ContextInterface $context);

    /**
     * Assembles pieces of code.
     *
     * @param ContextInterface $context
     * @throws AssemblerException
     */
    public function assemble(ContextInterface $context);
}
```

--------------------------------

### Generate value-objects with soap-client generate:types

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/cli/generate-types.md

Run the generator to create value-objects from XSD types in the WSDL. Requires a configuration file specified via --config. The output shows the command usage and options.

```sh
$ ./vendor/bin/soap-client generate:types
                                                                                                                                       [16:13:38]
Usage:
  generate:types [options]

Options:
      --config=CONFIG   The location of the soap code-generator config file

```

--------------------------------

### Configuration values for classmap generation

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/cli/generate-classmap.md

These configuration values must be set to generate a class map. The name is the class name, the namespace is where the class resides, and the destination is the relative path from the project root.

```php
->setClassMapName('MyClassmap')
->setClassMapNamespace('Myapp\\MyclassMap')
->setClassMapDestination('src/myapp/myclassmap')
```

--------------------------------

### Default Constructor Output

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Default constructor output without type hints or doc blocks disabled. Shows the generated constructor with all class properties as parameters.

```php
    /**
     * Constructor
     *
     * @var string $prop1
     * @var int $prop2
     */
    public function __construct($prop1, $prop2)
    {
        $this->prop1 = $prop1;
        $this->prop2 = $prop2;
    }
```

--------------------------------

### Use PrefixBasedTypeNamespaceStrategy with TypeNamespaceMap

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/configuration.md

Configures a TypeNamespaceMap with the built-in PrefixBasedTypeNamespaceStrategy. A type in the 'gml' xmlns prefix would be placed in 'src/Type/Gml' with namespace 'App\Type\Gml'. Explicit withMapping() entries take precedence over the strategy.

```php
use Phpro\SoapClient\CodeGenerator\Config\Destination;
use Phpro\SoapClient\CodeGenerator\Config\TypeNamespaceMap;
use Phpro\SoapClient\CodeGenerator\TypeNamespaceMap\Strategy\PrefixBasedTypeNamespaceStrategy;

TypeNamespaceMap::create(new Destination('src/Type', 'App\\Type'))
    ->withStrategy(new PrefixBasedTypeNamespaceStrategy())
```

--------------------------------

### ImmutableSetterAssembler constructor with options

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

Creates an ImmutableSetterAssembler with doc blocks disabled and type hints enabled. This is normally used in conjunction with withTypeHints.

```php
new ImmutableSetterAssembler((new ImmutableSetterAssemblerOptions())->withDocBlocks(false)->withTypeHints())
```

--------------------------------

### Upgrade soap-client to V4

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Upgrade the soap-client package to version 4.0.0 with the --update-with-dependencies flag to ensure dependencies are updated.

```bash
composer require 'phpro/soap-client:^4.0.0' --update-with-dependencies
```

--------------------------------

### IsAbstractTypeRule with AbstractClassAssembler

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/rules.md

Use in the "types" generation command to detect abstract types from SOAP metadata and run the subRule's assembler when matched. Requires engine metadata and a subRule. Can mark the PHP class as abstract.

```php
use Phpro\SoapClient\CodeGenerator\Assembler;
use Phpro\SoapClient\CodeGenerator\Rules;
use Soap\Engine\Metadata\Metadata;

assert($metadata instanceof Metadata);

new Rules\IsAbstractTypeRule(
    $metadata,
    new Rules\AssembleRule(new Assembler\AbstractClassAssembler())
)
```

--------------------------------

### ConstructorAssembler

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/assemblers.md

The ConstructorAssembler class is used to add a constructor with all class properties to the generated class. It can be configured with ConstructorAssemblerOptions to enable type hints, disable doc blocks, set default values strategy, and force optional values.

```APIDOC
## ConstructorAssembler

### Description
The `ConstructorAssembler` can be used to add a constructor with all the class properties to the generated class.

### Usage
Instantiate the `ConstructorAssembler` with optional `ConstructorAssemblerOptions`.

### Options
- `withTypeHints()` - Enables type hints in the constructor parameters. Disabled by default.
- `withDocBlocks(false)` - Disables doc blocks. Enabled by default.
- `withDefaultValues(DefaultValuesStrategy)` - Sets the default values strategy. Default is `OptionalOnly`.
- `withOptionalValue()` - Forces all parameters to be nullable with `= null`. Takes precedence over `withDefaultValues()`.

### DefaultValuesStrategy
- `OptionalOnly` (default): Only WSDL-optional/nullable parameters get `= null`. Parameters with defaults are reordered to the end.
- `All`: All scalar parameters get type-appropriate defaults (`''`, `0`, `false`, `0.0`, `[]`), nullable parameters get `= null`. Parameters with defaults are reordered to the end.
- `None`: No defaults are applied.

### Examples

#### Default (no type hints, doc blocks enabled)
```php
new ConstructorAssembler()
```

Output:
```php
    /**
     * Constructor
     *
     * @var string $prop1
     * @var int $prop2
     */
    public function __construct($prop1, $prop2)
    {
        $this->prop1 = $prop1;
        $this->prop2 = $prop2;
    }
```

#### With type hints
```php
new ConstructorAssembler((new ConstructorAssemblerOptions())->withTypeHints())
```

Output:
```php
    /**
     * Constructor
     *
     * @var string $prop1
     * @var int $prop2
     */
    public function __construct(string $prop1, int $prop2)
    {
        $this->prop1 = $prop1;
        $this->prop2 = $prop2;
    }
```

#### With type hints and no doc blocks
```php
new ConstructorAssembler((new ConstructorAssemblerOptions())->withDocBlocks(false)->withTypeHints())
```

Output:
```php
    public function __construct(string $prop1, int $prop2)
    {
        $this->prop1 = $prop1;
        $this->prop2 = $prop2;
    }
```

#### Default values strategy (OptionalOnly)
```php
new ConstructorAssembler((new ConstructorAssemblerOptions())->withTypeHints())
```

Output:
```php
    public function __construct(string $name, SomeClass $obj, ?Contact $contact = null)
    {
        $this->name = $name;
        $this->obj = $obj;
        $this->contact = $contact;
    }
```

#### Default values strategy (All)
```php
new ConstructorAssembler((new ConstructorAssemblerOptions())->withTypeHints()->withDefaultValues(DefaultValuesStrategy::All))
```

Output:
```php
    public function __construct(SomeClass $obj, string $prop1 = '', int $prop2 = 0)
    {
        $this->obj = $obj;
        $this->prop1 = $prop1;
        $this->prop2 = $prop2;
    }
```

#### Default values strategy (None)
```php
new ConstructorAssembler((new ConstructorAssemblerOptions())->withDefaultValues(DefaultValuesStrategy::None))
```

#### Optional values
```php
new ConstructorAssembler((new ConstructorAssemblerOptions())->withOptionalValue())
```

Output:
```php
    public function __construct(?string $prop1 = null, ?SomeClass $prop2 = null)
    {
        $this->prop1 = $prop1;
        $this->prop2 = $prop2;
    }
```

Note: `withOptionalValue()` takes precedence over `withDefaultValues()`: when both are enabled, all parameters become `?Type = null`.

```

--------------------------------

### IsRequestRule with RequestAssembler

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/rules.md

Use in the "types" generation command to guess request types from SOAP metadata and run the subRule's assembler when matched. Requires engine metadata and a subRule. Can add the required RequestInterface to request objects.

```php
use Phpro\SoapClient\CodeGenerator\Assembler;
use Phpro\SoapClient\CodeGenerator\Rules;
use Soap\Engine\Metadata\Metadata;

assert($metadata instanceof Metadata);

new Rules\IsRequestRule(
    $metadata,
    new Rules\AssembleRule(new Assembler\RequestAssembler())
)
```

--------------------------------

### Configure custom coding standards with Config::setCodingStandards()

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Configure a custom coding standards strategy via Config::setCodingStandards(). The default DefaultCodingStandardsStrategy matches the existing Normalizer behavior, so no changes are required for existing users.

```php
use Phpro\SoapClient\CodeGenerator\CodingStandards\CodingStandardsStrategyInterface;
use Phpro\SoapClient\CodeGenerator\Config\Config;

return ($config = Config::create())
    ->setCodingStandards(new MyCodingStandards())
    ->setEngine(...)
    ->setTypeNamespaceMap(...)
    // ...
```

--------------------------------

### Implement RuleInterface for custom code generation rule

Source: https://github.com/phpro/soap-client/blob/v6.x/docs/code-generation/rules.md

Implement this interface to create a custom rule for the SOAP client code generator. The appliesToContext method determines if the rule applies to a given context, and the apply method performs the rule's action.

```php
/**
 * Interface RuleInterface
 *
 * @package Phpro\SoapClient\CodeGenerator\Rules
 */
interface RuleInterface
{
    /**
     * @param ContextInterface $context
     *
     * @return bool
     */
    public function appliesToContext(ContextInterface $context);

    /**
     * @param ContextInterface $context
     */
    public function apply(ContextInterface $context);
}
```

--------------------------------

### Composer require phpro/soap-client ^3.0.0

Source: https://github.com/phpro/soap-client/blob/v6.x/UPGRADING.md

Run this command to update the phpro/soap-client dependency to version 3.0.0 or higher within the 3.x range, using --update-with-dependencies to update dependencies as well.

```bash
composer require 'phpro/soap-client:^3.0.0' --update-with-dependencies
```
Tokens:
Raw