Google Cloud Certificate Manager V1 Client - Class CertificateManagerClient (0.4.2)

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\Certificate;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\CreateCertificateRequest;
use Google\Rpc\Status;

/**
 * @param string $formattedParent The parent resource of the certificate. Must be in the format
 *                                `projects/*/locations/*`. Please see
 *                                {@see CertificateManagerClient::locationName()} for help formatting this field.
 * @param string $certificateId   A user-provided name of the certificate.
 */
function create_certificate_sample(string $formattedParent, string $certificateId): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $certificate = new Certificate();
    $request = (new CreateCertificateRequest())
        ->setParent($formattedParent)
        ->setCertificateId($certificateId)
        ->setCertificate($certificate);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->createCertificate($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            /** @var Certificate $result */
            $result = $response->getResult();
            printf('Operation successful with response data: %s' . PHP_EOL, $result->serializeToJsonString());
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = CertificateManagerClient::locationName('[PROJECT]', '[LOCATION]');
    $certificateId = '[CERTIFICATE_ID]';

    create_certificate_sample($formattedParent, $certificateId);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\CertificateIssuanceConfig;
use Google\Cloud\CertificateManager\V1\CertificateIssuanceConfig\CertificateAuthorityConfig;
use Google\Cloud\CertificateManager\V1\CertificateIssuanceConfig\KeyAlgorithm;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\CreateCertificateIssuanceConfigRequest;
use Google\Protobuf\Duration;
use Google\Rpc\Status;

/**
 * @param string $formattedParent                                   The parent resource of the certificate issuance config. Must be
 *                                                                  in the format `projects/*/locations/*`. Please see
 *                                                                  {@see CertificateManagerClient::locationName()} for help formatting this field.
 * @param string $certificateIssuanceConfigId                       A user-provided name of the certificate config.
 * @param int    $certificateIssuanceConfigRotationWindowPercentage Specifies the percentage of elapsed time of the certificate
 *                                                                  lifetime to wait before renewing the certificate. Must be a number between
 *                                                                  1-99, inclusive.
 * @param int    $certificateIssuanceConfigKeyAlgorithm             The key algorithm to use when generating the private key.
 */
function create_certificate_issuance_config_sample(
    string $formattedParent,
    string $certificateIssuanceConfigId,
    int $certificateIssuanceConfigRotationWindowPercentage,
    int $certificateIssuanceConfigKeyAlgorithm
): void {
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $certificateIssuanceConfigCertificateAuthorityConfig = new CertificateAuthorityConfig();
    $certificateIssuanceConfigLifetime = new Duration();
    $certificateIssuanceConfig = (new CertificateIssuanceConfig())
        ->setCertificateAuthorityConfig($certificateIssuanceConfigCertificateAuthorityConfig)
        ->setLifetime($certificateIssuanceConfigLifetime)
        ->setRotationWindowPercentage($certificateIssuanceConfigRotationWindowPercentage)
        ->setKeyAlgorithm($certificateIssuanceConfigKeyAlgorithm);
    $request = (new CreateCertificateIssuanceConfigRequest())
        ->setParent($formattedParent)
        ->setCertificateIssuanceConfigId($certificateIssuanceConfigId)
        ->setCertificateIssuanceConfig($certificateIssuanceConfig);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->createCertificateIssuanceConfig($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            /** @var CertificateIssuanceConfig $result */
            $result = $response->getResult();
            printf('Operation successful with response data: %s' . PHP_EOL, $result->serializeToJsonString());
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = CertificateManagerClient::locationName('[PROJECT]', '[LOCATION]');
    $certificateIssuanceConfigId = '[CERTIFICATE_ISSUANCE_CONFIG_ID]';
    $certificateIssuanceConfigRotationWindowPercentage = 0;
    $certificateIssuanceConfigKeyAlgorithm = KeyAlgorithm::KEY_ALGORITHM_UNSPECIFIED;

    create_certificate_issuance_config_sample(
        $formattedParent,
        $certificateIssuanceConfigId,
        $certificateIssuanceConfigRotationWindowPercentage,
        $certificateIssuanceConfigKeyAlgorithm
    );
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\CertificateMap;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\CreateCertificateMapRequest;
use Google\Rpc\Status;

/**
 * @param string $formattedParent  The parent resource of the certificate map. Must be in the format
 *                                 `projects/*/locations/*`. Please see
 *                                 {@see CertificateManagerClient::locationName()} for help formatting this field.
 * @param string $certificateMapId A user-provided name of the certificate map.
 */
function create_certificate_map_sample(string $formattedParent, string $certificateMapId): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $certificateMap = new CertificateMap();
    $request = (new CreateCertificateMapRequest())
        ->setParent($formattedParent)
        ->setCertificateMapId($certificateMapId)
        ->setCertificateMap($certificateMap);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->createCertificateMap($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            /** @var CertificateMap $result */
            $result = $response->getResult();
            printf('Operation successful with response data: %s' . PHP_EOL, $result->serializeToJsonString());
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = CertificateManagerClient::locationName('[PROJECT]', '[LOCATION]');
    $certificateMapId = '[CERTIFICATE_MAP_ID]';

    create_certificate_map_sample($formattedParent, $certificateMapId);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\CertificateMapEntry;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\CreateCertificateMapEntryRequest;
use Google\Rpc\Status;

/**
 * @param string $formattedParent       The parent resource of the certificate map entry. Must be in the
 *                                      format `projects/*/locations/*/certificateMaps/*`. Please see
 *                                      {@see CertificateManagerClient::certificateMapName()} for help formatting this field.
 * @param string $certificateMapEntryId A user-provided name of the certificate map entry.
 */
function create_certificate_map_entry_sample(
    string $formattedParent,
    string $certificateMapEntryId
): void {
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $certificateMapEntry = new CertificateMapEntry();
    $request = (new CreateCertificateMapEntryRequest())
        ->setParent($formattedParent)
        ->setCertificateMapEntryId($certificateMapEntryId)
        ->setCertificateMapEntry($certificateMapEntry);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->createCertificateMapEntry($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            /** @var CertificateMapEntry $result */
            $result = $response->getResult();
            printf('Operation successful with response data: %s' . PHP_EOL, $result->serializeToJsonString());
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = CertificateManagerClient::certificateMapName(
        '[PROJECT]',
        '[LOCATION]',
        '[CERTIFICATE_MAP]'
    );
    $certificateMapEntryId = '[CERTIFICATE_MAP_ENTRY_ID]';

    create_certificate_map_entry_sample($formattedParent, $certificateMapEntryId);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\CreateDnsAuthorizationRequest;
use Google\Cloud\CertificateManager\V1\DnsAuthorization;
use Google\Rpc\Status;

/**
 * @param string $formattedParent        The parent resource of the dns authorization. Must be in the
 *                                       format `projects/*/locations/*`. Please see
 *                                       {@see CertificateManagerClient::locationName()} for help formatting this field.
 * @param string $dnsAuthorizationId     A user-provided name of the dns authorization.
 * @param string $dnsAuthorizationDomain Immutable. A domain that is being authorized. A DnsAuthorization
 *                                       resource covers a single domain and its wildcard, e.g. authorization for
 *                                       `example.com` can be used to issue certificates for `example.com` and
 *                                       `*.example.com`.
 */
function create_dns_authorization_sample(
    string $formattedParent,
    string $dnsAuthorizationId,
    string $dnsAuthorizationDomain
): void {
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $dnsAuthorization = (new DnsAuthorization())
        ->setDomain($dnsAuthorizationDomain);
    $request = (new CreateDnsAuthorizationRequest())
        ->setParent($formattedParent)
        ->setDnsAuthorizationId($dnsAuthorizationId)
        ->setDnsAuthorization($dnsAuthorization);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->createDnsAuthorization($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            /** @var DnsAuthorization $result */
            $result = $response->getResult();
            printf('Operation successful with response data: %s' . PHP_EOL, $result->serializeToJsonString());
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = CertificateManagerClient::locationName('[PROJECT]', '[LOCATION]');
    $dnsAuthorizationId = '[DNS_AUTHORIZATION_ID]';
    $dnsAuthorizationDomain = '[DOMAIN]';

    create_dns_authorization_sample($formattedParent, $dnsAuthorizationId, $dnsAuthorizationDomain);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\DeleteCertificateRequest;
use Google\Rpc\Status;

/**
 * @param string $formattedName A name of the certificate to delete. Must be in the format
 *                              `projects/*/locations/*/certificates/*`. Please see
 *                              {@see CertificateManagerClient::certificateName()} for help formatting this field.
 */
function delete_certificate_sample(string $formattedName): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new DeleteCertificateRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->deleteCertificate($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            printf('Operation completed successfully.' . PHP_EOL);
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CertificateManagerClient::certificateName(
        '[PROJECT]',
        '[LOCATION]',
        '[CERTIFICATE]'
    );

    delete_certificate_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\DeleteCertificateIssuanceConfigRequest;
use Google\Rpc\Status;

/**
 * @param string $formattedName A name of the certificate issuance config to delete. Must be in
 *                              the format `projects/*/locations/*/certificateIssuanceConfigs/*`. Please see
 *                              {@see CertificateManagerClient::certificateIssuanceConfigName()} for help formatting this field.
 */
function delete_certificate_issuance_config_sample(string $formattedName): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new DeleteCertificateIssuanceConfigRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->deleteCertificateIssuanceConfig($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            printf('Operation completed successfully.' . PHP_EOL);
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CertificateManagerClient::certificateIssuanceConfigName(
        '[PROJECT]',
        '[LOCATION]',
        '[CERTIFICATE_ISSUANCE_CONFIG]'
    );

    delete_certificate_issuance_config_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\DeleteCertificateMapRequest;
use Google\Rpc\Status;

/**
 * @param string $formattedName A name of the certificate map to delete. Must be in the format
 *                              `projects/*/locations/*/certificateMaps/*`. Please see
 *                              {@see CertificateManagerClient::certificateMapName()} for help formatting this field.
 */
function delete_certificate_map_sample(string $formattedName): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new DeleteCertificateMapRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->deleteCertificateMap($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            printf('Operation completed successfully.' . PHP_EOL);
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CertificateManagerClient::certificateMapName(
        '[PROJECT]',
        '[LOCATION]',
        '[CERTIFICATE_MAP]'
    );

    delete_certificate_map_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\DeleteCertificateMapEntryRequest;
use Google\Rpc\Status;

/**
 * @param string $formattedName A name of the certificate map entry to delete. Must be in the
 *                              format `projects/*/locations/*/certificateMaps/*/certificateMapEntries/*`. Please see
 *                              {@see CertificateManagerClient::certificateMapEntryName()} for help formatting this field.
 */
function delete_certificate_map_entry_sample(string $formattedName): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new DeleteCertificateMapEntryRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->deleteCertificateMapEntry($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            printf('Operation completed successfully.' . PHP_EOL);
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CertificateManagerClient::certificateMapEntryName(
        '[PROJECT]',
        '[LOCATION]',
        '[CERTIFICATE_MAP]',
        '[CERTIFICATE_MAP_ENTRY]'
    );

    delete_certificate_map_entry_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\DeleteDnsAuthorizationRequest;
use Google\Rpc\Status;

/**
 * @param string $formattedName A name of the dns authorization to delete. Must be in the format
 *                              `projects/*/locations/*/dnsAuthorizations/*`. Please see
 *                              {@see CertificateManagerClient::dnsAuthorizationName()} for help formatting this field.
 */
function delete_dns_authorization_sample(string $formattedName): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new DeleteDnsAuthorizationRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->deleteDnsAuthorization($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            printf('Operation completed successfully.' . PHP_EOL);
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CertificateManagerClient::dnsAuthorizationName(
        '[PROJECT]',
        '[LOCATION]',
        '[DNS_AUTHORIZATION]'
    );

    delete_dns_authorization_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\CertificateManager\V1\Certificate;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\GetCertificateRequest;

/**
 * @param string $formattedName A name of the certificate to describe. Must be in the format
 *                              `projects/*/locations/*/certificates/*`. Please see
 *                              {@see CertificateManagerClient::certificateName()} for help formatting this field.
 */
function get_certificate_sample(string $formattedName): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new GetCertificateRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var Certificate $response */
        $response = $certificateManagerClient->getCertificate($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CertificateManagerClient::certificateName(
        '[PROJECT]',
        '[LOCATION]',
        '[CERTIFICATE]'
    );

    get_certificate_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\CertificateManager\V1\CertificateIssuanceConfig;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\GetCertificateIssuanceConfigRequest;

/**
 * @param string $formattedName A name of the certificate issuance config to describe. Must be in
 *                              the format `projects/*/locations/*/certificateIssuanceConfigs/*`. Please see
 *                              {@see CertificateManagerClient::certificateIssuanceConfigName()} for help formatting this field.
 */
function get_certificate_issuance_config_sample(string $formattedName): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new GetCertificateIssuanceConfigRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var CertificateIssuanceConfig $response */
        $response = $certificateManagerClient->getCertificateIssuanceConfig($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CertificateManagerClient::certificateIssuanceConfigName(
        '[PROJECT]',
        '[LOCATION]',
        '[CERTIFICATE_ISSUANCE_CONFIG]'
    );

    get_certificate_issuance_config_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\CertificateManager\V1\CertificateMap;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\GetCertificateMapRequest;

/**
 * @param string $formattedName A name of the certificate map to describe. Must be in the format
 *                              `projects/*/locations/*/certificateMaps/*`. Please see
 *                              {@see CertificateManagerClient::certificateMapName()} for help formatting this field.
 */
function get_certificate_map_sample(string $formattedName): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new GetCertificateMapRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var CertificateMap $response */
        $response = $certificateManagerClient->getCertificateMap($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CertificateManagerClient::certificateMapName(
        '[PROJECT]',
        '[LOCATION]',
        '[CERTIFICATE_MAP]'
    );

    get_certificate_map_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\CertificateManager\V1\CertificateMapEntry;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\GetCertificateMapEntryRequest;

/**
 * @param string $formattedName A name of the certificate map entry to describe. Must be in the
 *                              format `projects/*/locations/*/certificateMaps/*/certificateMapEntries/*`. Please see
 *                              {@see CertificateManagerClient::certificateMapEntryName()} for help formatting this field.
 */
function get_certificate_map_entry_sample(string $formattedName): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new GetCertificateMapEntryRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var CertificateMapEntry $response */
        $response = $certificateManagerClient->getCertificateMapEntry($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CertificateManagerClient::certificateMapEntryName(
        '[PROJECT]',
        '[LOCATION]',
        '[CERTIFICATE_MAP]',
        '[CERTIFICATE_MAP_ENTRY]'
    );

    get_certificate_map_entry_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\DnsAuthorization;
use Google\Cloud\CertificateManager\V1\GetDnsAuthorizationRequest;

/**
 * @param string $formattedName A name of the dns authorization to describe. Must be in the
 *                              format `projects/*/locations/*/dnsAuthorizations/*`. Please see
 *                              {@see CertificateManagerClient::dnsAuthorizationName()} for help formatting this field.
 */
function get_dns_authorization_sample(string $formattedName): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new GetDnsAuthorizationRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var DnsAuthorization $response */
        $response = $certificateManagerClient->getDnsAuthorization($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = CertificateManagerClient::dnsAuthorizationName(
        '[PROJECT]',
        '[LOCATION]',
        '[DNS_AUTHORIZATION]'
    );

    get_dns_authorization_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Cloud\CertificateManager\V1\CertificateIssuanceConfig;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\ListCertificateIssuanceConfigsRequest;

/**
 * @param string $formattedParent The project and location from which the certificate should be
 *                                listed, specified in the format `projects/*/locations/*`. Please see
 *                                {@see CertificateManagerClient::locationName()} for help formatting this field.
 */
function list_certificate_issuance_configs_sample(string $formattedParent): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new ListCertificateIssuanceConfigsRequest())
        ->setParent($formattedParent);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $certificateManagerClient->listCertificateIssuanceConfigs($request);

        /** @var CertificateIssuanceConfig $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = CertificateManagerClient::locationName('[PROJECT]', '[LOCATION]');

    list_certificate_issuance_configs_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Cloud\CertificateManager\V1\CertificateMapEntry;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\ListCertificateMapEntriesRequest;

/**
 * @param string $formattedParent The project, location and certificate map from which the
 *                                certificate map entries should be listed, specified in the format
 *                                `projects/*/locations/*/certificateMaps/*`. Please see
 *                                {@see CertificateManagerClient::certificateMapName()} for help formatting this field.
 */
function list_certificate_map_entries_sample(string $formattedParent): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new ListCertificateMapEntriesRequest())
        ->setParent($formattedParent);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $certificateManagerClient->listCertificateMapEntries($request);

        /** @var CertificateMapEntry $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = CertificateManagerClient::certificateMapName(
        '[PROJECT]',
        '[LOCATION]',
        '[CERTIFICATE_MAP]'
    );

    list_certificate_map_entries_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Cloud\CertificateManager\V1\CertificateMap;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\ListCertificateMapsRequest;

/**
 * @param string $formattedParent The project and location from which the certificate maps should
 *                                be listed, specified in the format `projects/*/locations/*`. Please see
 *                                {@see CertificateManagerClient::locationName()} for help formatting this field.
 */
function list_certificate_maps_sample(string $formattedParent): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new ListCertificateMapsRequest())
        ->setParent($formattedParent);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $certificateManagerClient->listCertificateMaps($request);

        /** @var CertificateMap $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = CertificateManagerClient::locationName('[PROJECT]', '[LOCATION]');

    list_certificate_maps_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Cloud\CertificateManager\V1\Certificate;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\ListCertificatesRequest;

/**
 * @param string $formattedParent The project and location from which the certificate should be
 *                                listed, specified in the format `projects/*/locations/*`. Please see
 *                                {@see CertificateManagerClient::locationName()} for help formatting this field.
 */
function list_certificates_sample(string $formattedParent): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new ListCertificatesRequest())
        ->setParent($formattedParent);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $certificateManagerClient->listCertificates($request);

        /** @var Certificate $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = CertificateManagerClient::locationName('[PROJECT]', '[LOCATION]');

    list_certificates_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\DnsAuthorization;
use Google\Cloud\CertificateManager\V1\ListDnsAuthorizationsRequest;

/**
 * @param string $formattedParent The project and location from which the dns authorizations should
 *                                be listed, specified in the format `projects/*/locations/*`. Please see
 *                                {@see CertificateManagerClient::locationName()} for help formatting this field.
 */
function list_dns_authorizations_sample(string $formattedParent): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = (new ListDnsAuthorizationsRequest())
        ->setParent($formattedParent);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $certificateManagerClient->listDnsAuthorizations($request);

        /** @var DnsAuthorization $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedParent = CertificateManagerClient::locationName('[PROJECT]', '[LOCATION]');

    list_dns_authorizations_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\Certificate;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\UpdateCertificateRequest;
use Google\Protobuf\FieldMask;
use Google\Rpc\Status;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function update_certificate_sample(): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $certificate = new Certificate();
    $updateMask = new FieldMask();
    $request = (new UpdateCertificateRequest())
        ->setCertificate($certificate)
        ->setUpdateMask($updateMask);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->updateCertificate($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            /** @var Certificate $result */
            $result = $response->getResult();
            printf('Operation successful with response data: %s' . PHP_EOL, $result->serializeToJsonString());
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\CertificateMap;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\UpdateCertificateMapRequest;
use Google\Protobuf\FieldMask;
use Google\Rpc\Status;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function update_certificate_map_sample(): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $certificateMap = new CertificateMap();
    $updateMask = new FieldMask();
    $request = (new UpdateCertificateMapRequest())
        ->setCertificateMap($certificateMap)
        ->setUpdateMask($updateMask);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->updateCertificateMap($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            /** @var CertificateMap $result */
            $result = $response->getResult();
            printf('Operation successful with response data: %s' . PHP_EOL, $result->serializeToJsonString());
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\CertificateMapEntry;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\UpdateCertificateMapEntryRequest;
use Google\Protobuf\FieldMask;
use Google\Rpc\Status;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function update_certificate_map_entry_sample(): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $certificateMapEntry = new CertificateMapEntry();
    $updateMask = new FieldMask();
    $request = (new UpdateCertificateMapEntryRequest())
        ->setCertificateMapEntry($certificateMapEntry)
        ->setUpdateMask($updateMask);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->updateCertificateMapEntry($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            /** @var CertificateMapEntry $result */
            $result = $response->getResult();
            printf('Operation successful with response data: %s' . PHP_EOL, $result->serializeToJsonString());
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\ApiCore\OperationResponse;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\CertificateManager\V1\DnsAuthorization;
use Google\Cloud\CertificateManager\V1\UpdateDnsAuthorizationRequest;
use Google\Protobuf\FieldMask;
use Google\Rpc\Status;

/**
 * @param string $dnsAuthorizationDomain Immutable. A domain that is being authorized. A DnsAuthorization
 *                                       resource covers a single domain and its wildcard, e.g. authorization for
 *                                       `example.com` can be used to issue certificates for `example.com` and
 *                                       `*.example.com`.
 */
function update_dns_authorization_sample(string $dnsAuthorizationDomain): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $dnsAuthorization = (new DnsAuthorization())
        ->setDomain($dnsAuthorizationDomain);
    $updateMask = new FieldMask();
    $request = (new UpdateDnsAuthorizationRequest())
        ->setDnsAuthorization($dnsAuthorization)
        ->setUpdateMask($updateMask);

    // Call the API and handle any network failures.
    try {
        /** @var OperationResponse $response */
        $response = $certificateManagerClient->updateDnsAuthorization($request);
        $response->pollUntilComplete();

        if ($response->operationSucceeded()) {
            /** @var DnsAuthorization $result */
            $result = $response->getResult();
            printf('Operation successful with response data: %s' . PHP_EOL, $result->serializeToJsonString());
        } else {
            /** @var Status $error */
            $error = $response->getError();
            printf('Operation failed with error data: %s' . PHP_EOL, $error->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $dnsAuthorizationDomain = '[DOMAIN]';

    update_dns_authorization_sample($dnsAuthorizationDomain);
}

use Google\ApiCore\ApiException;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\Location\GetLocationRequest;
use Google\Cloud\Location\Location;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function get_location_sample(): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = new GetLocationRequest();

    // Call the API and handle any network failures.
    try {
        /** @var Location $response */
        $response = $certificateManagerClient->getLocation($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Cloud\CertificateManager\V1\Client\CertificateManagerClient;
use Google\Cloud\Location\ListLocationsRequest;
use Google\Cloud\Location\Location;

/**
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function list_locations_sample(): void
{
    // Create a client.
    $certificateManagerClient = new CertificateManagerClient();

    // Prepare the request message.
    $request = new ListLocationsRequest();

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $certificateManagerClient->listLocations($request);

        /** @var Location $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}