Google Cloud Managed Kafka Schema Registry V1 Client - Class ManagedSchemaRegistryClient (0.1.1)

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\CheckCompatibilityRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\CheckCompatibilityResponse;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;

/**
 * @param string $name   The name of the resource to check compatibility for. The format
 *                       is either of following:
 *                       * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/compatibility/subjects/*/versions: Check compatibility with one or
 *                       more versions of the specified subject.
 *                       * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/compatibility/subjects/{subject}/versions/{version}: Check
 *                       compatibility with a specific version of the subject.
 * @param string $schema The schema payload
 */
function check_compatibility_sample(string $name, string $schema): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

    // Prepare the request message.
    $request = (new CheckCompatibilityRequest())
        ->setName($name)
        ->setSchema($schema);

    // Call the API and handle any network failures.
    try {
        /** @var CheckCompatibilityResponse $response */
        $response = $managedSchemaRegistryClient->checkCompatibility($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
{
    $name = '[NAME]';
    $schema = '[SCHEMA]';

    check_compatibility_sample($name, $schema);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\CreateSchemaRegistryRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaRegistry;

/**
 * @param string $parent           The parent whose schema registry instance is to be created.
 *                                 Structured like: `projects/{project}/locations/{___location}`
 * @param string $schemaRegistryId The schema registry instance ID to use for this schema registry.
 *                                 The ID must contain only letters (a-z, A-Z), numbers (0-9), and underscores
 *                                 (-). The maximum length is 63 characters.
 *                                 The ID must not start with a number.
 */
function create_schema_registry_sample(string $parent, string $schemaRegistryId): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

    // Prepare the request message.
    $schemaRegistry = new SchemaRegistry();
    $request = (new CreateSchemaRegistryRequest())
        ->setParent($parent)
        ->setSchemaRegistryId($schemaRegistryId)
        ->setSchemaRegistry($schemaRegistry);

    // Call the API and handle any network failures.
    try {
        /** @var SchemaRegistry $response */
        $response = $managedSchemaRegistryClient->createSchemaRegistry($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
{
    $parent = '[PARENT]';
    $schemaRegistryId = '[SCHEMA_REGISTRY_ID]';

    create_schema_registry_sample($parent, $schemaRegistryId);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\CreateVersionRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\CreateVersionResponse;

/**
 * @param string $formattedParent The subject to create the version for. Structured like:
 *                                `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/subjects/{subject}`
 *                                or
 *                                `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}`
 *                                Please see {@see ManagedSchemaRegistryClient::schemaSubjectName()} for help formatting this field.
 * @param string $schema          The schema payload
 */
function create_version_sample(string $formattedParent, string $schema): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var CreateVersionResponse $response */
        $response = $managedSchemaRegistryClient->createVersion($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
{
    $formattedParent = ManagedSchemaRegistryClient::schemaSubjectName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[SUBJECT]'
    );
    $schema = '[SCHEMA]';

    create_version_sample($formattedParent, $schema);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\DeleteSchemaConfigRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaConfig;

/**
 * @param string $formattedName The resource name of subject to delete the config for. The format
 *                              is
 *                              * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/config/{subject}
 *                              Please see {@see ManagedSchemaRegistryClient::schemaConfigName()} for help formatting this field.
 */
function delete_schema_config_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var SchemaConfig $response */
        $response = $managedSchemaRegistryClient->deleteSchemaConfig($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 = ManagedSchemaRegistryClient::schemaConfigName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]'
    );

    delete_schema_config_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\DeleteSchemaModeRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaMode;

/**
 * @param string $formattedName The resource name of subject to delete the mode for. The format
 *                              is
 *                              * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/mode/{subject}
 *                              * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/mode/{subject}
 *                              Please see {@see ManagedSchemaRegistryClient::schemaModeName()} for help formatting this field.
 */
function delete_schema_mode_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var SchemaMode $response */
        $response = $managedSchemaRegistryClient->deleteSchemaMode($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 = ManagedSchemaRegistryClient::schemaModeName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]'
    );

    delete_schema_mode_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\DeleteSchemaRegistryRequest;

/**
 * @param string $formattedName The name of the schema registry instance to delete. Structured
 *                              like:
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}`
 *                              Please see {@see ManagedSchemaRegistryClient::schemaRegistryName()} for help formatting this field.
 */
function delete_schema_registry_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        $managedSchemaRegistryClient->deleteSchemaRegistry($request);
        printf('Call completed successfully.' . PHP_EOL);
    } 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 = ManagedSchemaRegistryClient::schemaRegistryName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]'
    );

    delete_schema_registry_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Api\HttpBody;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\DeleteSubjectRequest;

/**
 * @param string $formattedName The name of the subject to delete. Structured like:
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/subjects/{subject}`
 *                              or
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}`
 *                              Please see {@see ManagedSchemaRegistryClient::schemaSubjectName()} for help formatting this field.
 */
function delete_subject_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var HttpBody $response */
        $response = $managedSchemaRegistryClient->deleteSubject($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 = ManagedSchemaRegistryClient::schemaSubjectName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[SUBJECT]'
    );

    delete_subject_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Api\HttpBody;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\DeleteVersionRequest;

/**
 * @param string $formattedName The name of the subject version to delete. Structured like:
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/subjects/{subject}/versions/{version}`
 *                              or
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}/versions/{version}`
 *                              Please see {@see ManagedSchemaRegistryClient::schemaVersionName()} for help formatting this field.
 */
function delete_version_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var HttpBody $response */
        $response = $managedSchemaRegistryClient->deleteVersion($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 = ManagedSchemaRegistryClient::schemaVersionName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[SUBJECT]',
        '[VERSION]'
    );

    delete_version_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Context;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\GetContextRequest;

/**
 * @param string $formattedName The name of the context to return. Structured like:
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}`
 *                              Please see {@see ManagedSchemaRegistryClient::schemaContextName()} for help formatting this field.
 */
function get_context_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var Context $response */
        $response = $managedSchemaRegistryClient->getContext($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 = ManagedSchemaRegistryClient::schemaContextName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[CONTEXT]'
    );

    get_context_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Api\HttpBody;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\GetSchemaRequest;

/**
 * @param string $formattedName The name of the schema to return. Structured like:
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}`
 *                              Please see {@see ManagedSchemaRegistryClient::schemaName()} for help formatting this field.
 */
function get_raw_schema_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var HttpBody $response */
        $response = $managedSchemaRegistryClient->getRawSchema($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 = ManagedSchemaRegistryClient::schemaName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[SCHEMA]'
    );

    get_raw_schema_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Api\HttpBody;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\GetVersionRequest;

/**
 * @param string $formattedName The name of the subject to return versions. Structured like:
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/subjects/{subject}/versions/{version}`
 *                              or
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}/versions/{version}`
 *                              Please see {@see ManagedSchemaRegistryClient::schemaVersionName()} for help formatting this field.
 */
function get_raw_schema_version_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var HttpBody $response */
        $response = $managedSchemaRegistryClient->getRawSchemaVersion($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 = ManagedSchemaRegistryClient::schemaVersionName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[SUBJECT]',
        '[VERSION]'
    );

    get_raw_schema_version_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\GetSchemaRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Schema;

/**
 * @param string $formattedName The name of the schema to return. Structured like:
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}`
 *                              Please see {@see ManagedSchemaRegistryClient::schemaName()} for help formatting this field.
 */
function get_schema_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var Schema $response */
        $response = $managedSchemaRegistryClient->getSchema($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 = ManagedSchemaRegistryClient::schemaName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[SCHEMA]'
    );

    get_schema_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\GetSchemaConfigRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaConfig;

/**
 * @param string $formattedName The resource name to get the config for. It can be either of
 *                              following:
 *                              * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/config: Get config at global level.
 *                              * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/config/{subject}: Get config for a specific subject. Please see
 *                              {@see ManagedSchemaRegistryClient::schemaConfigName()} for help formatting this field.
 */
function get_schema_config_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var SchemaConfig $response */
        $response = $managedSchemaRegistryClient->getSchemaConfig($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 = ManagedSchemaRegistryClient::schemaConfigName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]'
    );

    get_schema_config_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\GetSchemaModeRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaMode;

/**
 * @param string $formattedName The resource name of the mode. The format is
 *                              * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/mode/{subject}: mode for a schema registry, or
 *                              * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/mode/{subject}: mode for a specific subject in a specific context
 *                              Please see {@see ManagedSchemaRegistryClient::schemaModeName()} for help formatting this field.
 */
function get_schema_mode_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var SchemaMode $response */
        $response = $managedSchemaRegistryClient->getSchemaMode($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 = ManagedSchemaRegistryClient::schemaModeName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]'
    );

    get_schema_mode_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\GetSchemaRegistryRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaRegistry;

/**
 * @param string $formattedName The name of the schema registry instance to return. Structured
 *                              like:
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}`
 *                              Please see {@see ManagedSchemaRegistryClient::schemaRegistryName()} for help formatting this field.
 */
function get_schema_registry_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var SchemaRegistry $response */
        $response = $managedSchemaRegistryClient->getSchemaRegistry($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 = ManagedSchemaRegistryClient::schemaRegistryName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]'
    );

    get_schema_registry_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\GetVersionRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaVersion;

/**
 * @param string $formattedName The name of the subject to return versions. Structured like:
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/subjects/{subject}/versions/{version}`
 *                              or
 *                              `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}/versions/{version}`
 *                              Please see {@see ManagedSchemaRegistryClient::schemaVersionName()} for help formatting this field.
 */
function get_version_sample(string $formattedName): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var SchemaVersion $response */
        $response = $managedSchemaRegistryClient->getVersion($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 = ManagedSchemaRegistryClient::schemaVersionName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[SUBJECT]',
        '[VERSION]'
    );

    get_version_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Api\HttpBody;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\ListContextsRequest;

/**
 * @param string $formattedParent The parent of the contexts. Structured like:
 *                                `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}`
 *                                Please see {@see ManagedSchemaRegistryClient::schemaRegistryName()} for help formatting this field.
 */
function list_contexts_sample(string $formattedParent): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var HttpBody $response */
        $response = $managedSchemaRegistryClient->listContexts($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
{
    $formattedParent = ManagedSchemaRegistryClient::schemaRegistryName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]'
    );

    list_contexts_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\Api\HttpBody;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\ListReferencedSchemasRequest;

/**
 * @param string $formattedParent The version to list referenced by. Structured like:
 *                                `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/subjects/{subject}/versions/{version}`
 *                                or
 *                                `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}/versions/{version}`
 *                                Please see {@see ManagedSchemaRegistryClient::schemaVersionName()} for help formatting this field.
 */
function list_referenced_schemas_sample(string $formattedParent): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var HttpBody $response */
        $response = $managedSchemaRegistryClient->listReferencedSchemas($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
{
    $formattedParent = ManagedSchemaRegistryClient::schemaVersionName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[SUBJECT]',
        '[VERSION]'
    );

    list_referenced_schemas_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\ListSchemaRegistriesRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\ListSchemaRegistriesResponse;

/**
 * @param string $parent The parent whose schema registry instances are to be listed.
 *                       Structured like: `projects/{project}/locations/{___location}`
 */
function list_schema_registries_sample(string $parent): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

    // Prepare the request message.
    $request = (new ListSchemaRegistriesRequest())
        ->setParent($parent);

    // Call the API and handle any network failures.
    try {
        /** @var ListSchemaRegistriesResponse $response */
        $response = $managedSchemaRegistryClient->listSchemaRegistries($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
{
    $parent = '[PARENT]';

    list_schema_registries_sample($parent);
}

use Google\ApiCore\ApiException;
use Google\Api\HttpBody;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\ListSchemaTypesRequest;

/**
 * @param string $parent The parent schema registry whose schema types are to be listed.
 *                       Structured like:
 *                       `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}`
 */
function list_schema_types_sample(string $parent): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

    // Prepare the request message.
    $request = (new ListSchemaTypesRequest())
        ->setParent($parent);

    // Call the API and handle any network failures.
    try {
        /** @var HttpBody $response */
        $response = $managedSchemaRegistryClient->listSchemaTypes($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
{
    $parent = '[PARENT]';

    list_schema_types_sample($parent);
}

use Google\ApiCore\ApiException;
use Google\Api\HttpBody;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\ListSchemaVersionsRequest;

/**
 * @param string $formattedParent The schema whose schema versions are to be listed. Structured
 *                                like:
 *                                `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}`
 *                                or
 *                                `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/schemas/ids/{schema}`
 *                                Please see {@see ManagedSchemaRegistryClient::schemaName()} for help formatting this field.
 */
function list_schema_versions_sample(string $formattedParent): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var HttpBody $response */
        $response = $managedSchemaRegistryClient->listSchemaVersions($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
{
    $formattedParent = ManagedSchemaRegistryClient::schemaName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[SCHEMA]'
    );

    list_schema_versions_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\Api\HttpBody;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\ListSubjectsRequest;

/**
 * @param string $parent The parent schema registry/context whose subjects are to be
 *                       listed. Structured like:
 *                       `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}`
 *                       or
 *                       `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}`
 */
function list_subjects_sample(string $parent): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

    // Prepare the request message.
    $request = (new ListSubjectsRequest())
        ->setParent($parent);

    // Call the API and handle any network failures.
    try {
        /** @var HttpBody $response */
        $response = $managedSchemaRegistryClient->listSubjects($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
{
    $parent = '[PARENT]';

    list_subjects_sample($parent);
}

use Google\ApiCore\ApiException;
use Google\Api\HttpBody;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\ListSubjectsBySchemaIdRequest;

/**
 * @param string $parent The schema resource whose associated subjects are to be listed.
 *                       Structured like:
 *                       `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}`
 *                       or
 *                       `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/schemas/ids/{schema}`
 */
function list_subjects_by_schema_id_sample(string $parent): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

    // Prepare the request message.
    $request = (new ListSubjectsBySchemaIdRequest())
        ->setParent($parent);

    // Call the API and handle any network failures.
    try {
        /** @var HttpBody $response */
        $response = $managedSchemaRegistryClient->listSubjectsBySchemaId($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
{
    $parent = '[PARENT]';

    list_subjects_by_schema_id_sample($parent);
}

use Google\ApiCore\ApiException;
use Google\Api\HttpBody;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\ListVersionsRequest;

/**
 * @param string $formattedParent The subject whose versions are to be listed. Structured like:
 *                                `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/subjects/{subject}`
 *                                or
 *                                `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}`
 *                                Please see {@see ManagedSchemaRegistryClient::schemaSubjectName()} for help formatting this field.
 */
function list_versions_sample(string $formattedParent): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var HttpBody $response */
        $response = $managedSchemaRegistryClient->listVersions($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
{
    $formattedParent = ManagedSchemaRegistryClient::schemaSubjectName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[SUBJECT]'
    );

    list_versions_sample($formattedParent);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\LookupVersionRequest;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaVersion;

/**
 * @param string $formattedParent The subject to lookup the schema in. Structured like:
 *                                `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/subjects/{subject}`
 *                                or
 *                                `projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/subjects/{subject}`
 *                                Please see {@see ManagedSchemaRegistryClient::schemaSubjectName()} for help formatting this field.
 * @param string $schema          The schema payload
 */
function lookup_version_sample(string $formattedParent, string $schema): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var SchemaVersion $response */
        $response = $managedSchemaRegistryClient->lookupVersion($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
{
    $formattedParent = ManagedSchemaRegistryClient::schemaSubjectName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]',
        '[SUBJECT]'
    );
    $schema = '[SCHEMA]';

    lookup_version_sample($formattedParent, $schema);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaConfig;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaConfig\CompatibilityType;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\UpdateSchemaConfigRequest;

/**
 * @param string $formattedName The resource name to update the config for. It can be either of
 *                              following:
 *                              * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/config: Update config at global level.
 *                              * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/config/{subject}: Update config for a specific subject. Please see
 *                              {@see ManagedSchemaRegistryClient::schemaConfigName()} for help formatting this field.
 * @param int    $compatibility The compatibility type of the schemas.
 *                              Cannot be unset for a SchemaRegistry-level SchemaConfig.
 *                              If unset on a SchemaSubject-level SchemaConfig, removes the compatibility
 *                              field for the SchemaConfig.
 */
function update_schema_config_sample(string $formattedName, int $compatibility): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var SchemaConfig $response */
        $response = $managedSchemaRegistryClient->updateSchemaConfig($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 = ManagedSchemaRegistryClient::schemaConfigName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]'
    );
    $compatibility = CompatibilityType::NONE;

    update_schema_config_sample($formattedName, $compatibility);
}

use Google\ApiCore\ApiException;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaMode;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\SchemaMode\ModeType;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\UpdateSchemaModeRequest;

/**
 * @param string $formattedName The resource name of the mode. The format is
 *                              * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/mode/{subject}: mode for a schema registry, or
 *                              * projects/{project}/locations/{___location}/schemaRegistries/{schema_registry}/contexts/{context}/mode/{subject}: mode for a specific subject in a specific context
 *                              Please see {@see ManagedSchemaRegistryClient::schemaModeName()} for help formatting this field.
 * @param int    $mode          The mode type.
 */
function update_schema_mode_sample(string $formattedName, int $mode): void
{
    // Create a client.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var SchemaMode $response */
        $response = $managedSchemaRegistryClient->updateSchemaMode($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 = ManagedSchemaRegistryClient::schemaModeName(
        '[PROJECT]',
        '[LOCATION]',
        '[SCHEMA_REGISTRY]'
    );
    $mode = ModeType::NONE;

    update_schema_mode_sample($formattedName, $mode);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Location\GetLocationRequest;
use Google\Cloud\Location\Location;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;

/**
 * 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.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var Location $response */
        $response = $managedSchemaRegistryClient->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\Location\ListLocationsRequest;
use Google\Cloud\Location\Location;
use Google\Cloud\ManagedKafka\SchemaRegistry\V1\Client\ManagedSchemaRegistryClient;

/**
 * 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.
    $managedSchemaRegistryClient = new ManagedSchemaRegistryClient();

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

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $managedSchemaRegistryClient->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());
    }
}