# Class ManagedSchemaRegistryClient (0.4.1)

0.4.1 (latest) 0.4.0 0.3.0 0.2.0 0.1.0

    ManagedSchemaRegistryClient(
        *,
        credentials: typing.Optional[google.auth.credentials.Credentials] = None,
        transport: typing.Optional[
            typing.Union[
                str,
                google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.transports.base.ManagedSchemaRegistryTransport,
                typing.Callable[
                    [...],
                    google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.transports.base.ManagedSchemaRegistryTransport,
                ],
            ]
        ] = None,
        client_options: typing.Optional[
            typing.Union[google.api_core.client_options.ClientOptions, dict]
        ] = None,
        client_info: google.api_core.gapic_v1.client_info.ClientInfo = google.api_core.gapic_v1.client_info.ClientInfo
    )

SchemaRegistry is a service that allows users to manage schemas for
their Kafka clusters. It provides APIs to register, list, and delete
schemas, as well as to get the schema for a given schema id or a
given version id under a subject, to update the global or
subject-specific compatibility mode, and to check the compatibility
of a schema against a subject or a version. The main resource
hierarchy is as follows:

- SchemaRegistry
- SchemaRegistry/Context
- SchemaRegistry/Context/Schema
- SchemaRegistry/Context/Subject
- SchemaRegistry/Context/Subject/Version
- SchemaRegistry/Config
- SchemaRegistry/Mode

**SchemaRegistry** is the root resource to represent a schema
registry instance. A customer can have multiple schema registry
instances in a project.

**Context** is a context resource that represents a group of
schemas, subjects and versions. A schema registry instance can have
multiple contexts and always has a 'default' context. Contexts are
independent of each other. Context is optional and if not specified,
it falls back to the 'default' context.

**Schema** is a schema resource that represents a unique schema in a
context of a schema registry instance. Each schema has a unique
schema id, and can be referenced by a version of a subject.

**Subject** refers to the name under which the schema is registered.
A typical subject is the Kafka topic name. A schema registry
instance can have multiple subjects.

**Version** represents a version of a subject. A subject can have
multiple versions. Creation of new version of a subject is guarded
by the compatibility mode configured globally or for the subject
specifically.

**Config** represents a config at global level cross all registry
instances or at subject level. Currently, only compatibility is
supported in config.

**Mode** represents the mode of a schema registry or a specific
subject. Three modes are supported:

- READONLY: The schema registry is in read-only mode, no write operations allowed..
- READWRITE: The schema registry is in read-write mode, which allows limited write operations on the schema.
- IMPORT: The schema registry is in import mode, which allows more editing operations on the schema for data importing purposes.

## Properties

### api_endpoint

Return the API endpoint used by the client instance.

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `str` | The API endpoint used by the client instance. |

### transport

Returns the transport used by the client instance.

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `ManagedSchemaRegistryTransport` | The transport used by the client instance. |

### universe_domain

Return the universe domain used by the client instance.

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `str` | The universe domain used by the client instance. |

## Methods

### ManagedSchemaRegistryClient

    ManagedSchemaRegistryClient(
        *,
        credentials: typing.Optional[google.auth.credentials.Credentials] = None,
        transport: typing.Optional[
            typing.Union[
                str,
                google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.transports.base.ManagedSchemaRegistryTransport,
                typing.Callable[
                    [...],
                    google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.transports.base.ManagedSchemaRegistryTransport,
                ],
            ]
        ] = None,
        client_options: typing.Optional[
            typing.Union[google.api_core.client_options.ClientOptions, dict]
        ] = None,
        client_info: google.api_core.gapic_v1.client_info.ClientInfo = google.api_core.gapic_v1.client_info.ClientInfo
    )

Instantiates the managed schema registry client.

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `credentials` | `Optional[google.auth.credentials.Credentials]` The authorization credentials to attach to requests. These credentials identify the application to the service; if none are specified, the client will attempt to ascertain the credentials from the environment. |
| `transport` | `Optional[Union[str,ManagedSchemaRegistryTransport,Callable[..., ManagedSchemaRegistryTransport]]]` The transport to use, or a Callable that constructs and returns a new transport. If a Callable is given, it will be called with the same set of initialization arguments as used in the ManagedSchemaRegistryTransport constructor. If set to None, a transport is chosen automatically. |
| `client_options` | `Optional[Union[google.api_core.client_options.ClientOptions, dict]]` Custom options for the client. 1. The `api_endpoint` property can be used to override the default endpoint provided by the client when `transport` is not explicitly provided. Only if this property is not set and `transport` was not explicitly provided, the endpoint is determined by the GOOGLE_API_USE_MTLS_ENDPOINT environment variable, which have one of the following values: "always" (always use the default mTLS endpoint), "never" (always use the default regular endpoint) and "auto" (auto-switch to the default mTLS endpoint if client certificate is present; this is the default value). 2. If the GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable is "true", then the `client_cert_source` property can be used to provide a client certificate for mTLS transport. If not provided, the default SSL client certificate will be used if present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not set, no client certificate will be used. 3. The `universe_domain` property can be used to override the default "googleapis.com" universe. Note that the `api_endpoint` property still takes precedence; and `universe_domain` is currently not supported for mTLS. |
| `client_info` | `google.api_core.gapic_v1.client_info.ClientInfo` The client info used to send a user-agent string along with API requests. If `None`, then default info will be used. Generally, you only need to set this if you're developing your own client library. |

| **Exceptions** ||
|---|---|
| **Type** | **Description** |
| `google.auth.exceptions.MutualTLSChannelError` | If mutual TLS transport creation failed for any reason. |

### __exit__

    __exit__(type, value, traceback)

Releases underlying transport's resources.

> [!WARNING]
> **Warning:** ONLY use as a context manager if the transport is NOT shared with other clients! Exiting the with block will CLOSE the transport and may cause errors in other clients!

### cancel_operation

    cancel_operation(
        request: typing.Optional[
            typing.Union[google.longrunning.operations_pb2.CancelOperationRequest, dict]
        ] = None,
        *,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> None

Starts asynchronous cancellation on a long-running operation.

The server makes a best effort to cancel the operation, but success
is not guaranteed. If the server doesn't support this method, it returns
`google.rpc.Code.UNIMPLEMENTED`.

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `` `.operations_pb2.CancelOperationRequest` `` The request object. Request message for `CancelOperation` method. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

### check_compatibility

    check_compatibility(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.CheckCompatibilityRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        schema: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.CheckCompatibilityResponse
    )

Check compatibility of a schema with all versions or
a specific version of a subject.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_check_compatibility():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.CheckCompatibilityRequest.html(
            name="name_value",
            schema="schema_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_check_compatibility(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.CheckCompatibilityRequest, dict]` The request object. Request for CheckCompatibility. |
| `name` | `str` Required. 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. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `schema` | `str` Required. The schema payload This corresponds to the `schema` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.CheckCompatibilityResponse` | Response for CheckCompatibility. |

### common_billing_account_path

    common_billing_account_path(billing_account: str) -> str

Returns a fully-qualified billing_account string.

### common_folder_path

    common_folder_path(folder: str) -> str

Returns a fully-qualified folder string.

### common_location_path

    common_location_path(project: str, location: str) -> str

Returns a fully-qualified location string.

### common_organization_path

    common_organization_path(organization: str) -> str

Returns a fully-qualified organization string.

### common_project_path

    common_project_path(project: str) -> str

Returns a fully-qualified project string.

### create_schema_registry

    create_schema_registry(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.CreateSchemaRegistryRequest,
                dict,
            ]
        ] = None,
        *,
        parent: typing.Optional[str] = None,
        schema_registry: typing.Optional[
            google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaRegistry
        ] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaRegistry
    )

Create a schema registry instance.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_create_schema_registry():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.CreateSchemaRegistryRequest.html(
            parent="parent_value",
            schema_registry_id="schema_registry_id_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_create_schema_registry(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.CreateSchemaRegistryRequest, dict]` The request object. Request to create a schema registry instance. |
| `parent` | `str` Required. The parent whose schema registry instance is to be created. Structured like: `projects/{project}/locations/{location}` This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set. |
| `schema_registry` | `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaRegistry` Required. The schema registry instance to create. The name field is ignored. This corresponds to the `schema_registry` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaRegistry` | SchemaRegistry is a schema registry instance. |

### create_version

    create_version(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.CreateVersionRequest,
                dict,
            ]
        ] = None,
        *,
        parent: typing.Optional[str] = None,
        version: typing.Optional[int] = None,
        id: typing.Optional[int] = None,
        schema_type: typing.Optional[
            google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.Schema.SchemaType
        ] = None,
        schema: typing.Optional[str] = None,
        references: typing.Optional[
            typing.MutableSequence[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.Schema.SchemaReference
            ]
        ] = None,
        normalize: typing.Optional[bool] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.CreateVersionResponse
    )

Register a new version under a given subject with the
given schema.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_create_version():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.CreateVersionRequest.html(
            parent="parent_value",
            schema="schema_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_create_version(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.CreateVersionRequest, dict]` The request object. Request for CreateVersion. |
| `parent` | `str` Required. 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}` This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set. |
| `version` | `int` Optional. The version to create. It is optional. If not specified, the version will be created with the max version ID of the subject increased by 1. If the version ID is specified, it will be used as the new version ID and must not be used by an existing version of the subject. This corresponds to the `version` field on the `request` instance; if `request` is provided, this should not be set. |
| `id` | `int` Optional. The schema ID of the schema. If not specified, the schema ID will be generated by the server. If the schema ID is specified, it must not be used by an existing schema that is different from the schema to be created. This corresponds to the `id` field on the `request` instance; if `request` is provided, this should not be set. |
| `schema_type` | `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.Schema.SchemaType` Optional. The type of the schema. It is optional. If not specified, the schema type will be AVRO. This corresponds to the `schema_type` field on the `request` instance; if `request` is provided, this should not be set. |
| `schema` | `str` Required. The schema payload This corresponds to the `schema` field on the `request` instance; if `request` is provided, this should not be set. |
| `references` | `MutableSequence[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.Schema.SchemaReference]` Optional. The schema references used by the schema. This corresponds to the `references` field on the `request` instance; if `request` is provided, this should not be set. |
| `normalize` | `bool` Optional. If true, the schema will be normalized before being stored. The default is false. This corresponds to the `normalize` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.CreateVersionResponse` | Response for CreateVersion. |

### delete_operation

    delete_operation(
        request: typing.Optional[
            typing.Union[google.longrunning.operations_pb2.DeleteOperationRequest, dict]
        ] = None,
        *,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> None

Deletes a long-running operation.

This method indicates that the client is no longer interested
in the operation result. It does not cancel the operation.
If the server doesn't support this method, it returns
`google.rpc.Code.UNIMPLEMENTED`.

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `` `.operations_pb2.DeleteOperationRequest` `` The request object. Request message for `DeleteOperation` method. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

### delete_schema_config

    delete_schema_config(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.DeleteSchemaConfigRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaConfig
    )

Delete schema config for a subject.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_delete_schema_config():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.DeleteSchemaConfigRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_delete_schema_config(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.DeleteSchemaConfigRequest, dict]` The request object. Request for deleting schema config. |
| `name` | `str` Required. The resource name of subject to delete the config for. The format is - projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/config/{subject} This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaConfig` | SchemaConfig represents configuration for a schema registry or a specific subject. |

### delete_schema_mode

    delete_schema_mode(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.DeleteSchemaModeRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaMode
    )

Delete schema mode for a subject.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_delete_schema_mode():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.DeleteSchemaModeRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_delete_schema_mode(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.DeleteSchemaModeRequest, dict]` The request object. Request for deleting schema mode. |
| `name` | `str` Required. 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} This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaMode` | SchemaMode represents the mode of a schema registry or a specific subject. Four modes are supported: \\\* NONE: deprecated. This was the default mode for a subject, but now the default is unset (which means use the global schema registry setting) \\\* READONLY: The schema registry is in read-only mode. \\\* READWRITE: The schema registry is in read-write mode, which allows limited write operations on the schema. \\\* IMPORT: The schema registry is in import mode, which allows more editing operations on the schema for data importing purposes. |

### delete_schema_registry

    delete_schema_registry(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.DeleteSchemaRegistryRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> None

Delete a schema registry instance.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_delete_schema_registry():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.DeleteSchemaRegistryRequest.html(
            name="name_value",
        )

        # Make the request
        client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_delete_schema_registry(request=request)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.DeleteSchemaRegistryRequest, dict]` The request object. Request for DeleteSchemaRegistry. |
| `name` | `str` Required. The name of the schema registry instance to delete. Structured like: `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}` This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

### delete_subject

    delete_subject(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.DeleteSubjectRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.api.httpbody_pb2.HttpBody

Delete a subject.
The response will be an array of versions of the deleted
subject.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_delete_subject():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.DeleteSubjectRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_delete_subject(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.DeleteSubjectRequest, dict]` The request object. Request for DeleteSubject. |
| `name` | `str` Required. 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}` This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `google.api.httpbody_pb2.HttpBody` | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. |

### delete_version

    delete_version(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.DeleteVersionRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.api.httpbody_pb2.HttpBody

Delete a version of a subject.
The response will be the deleted version id.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_delete_version():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.DeleteVersionRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_delete_version(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.DeleteVersionRequest, dict]` The request object. Request for DeleteVersion. |
| `name` | `str` Required. 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}` This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `google.api.httpbody_pb2.HttpBody` | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. |

### from_service_account_file

    from_service_account_file(filename: str, *args, **kwargs)

Creates an instance of this client using the provided credentials
file.

| **Parameter** ||
|---|---|
| **Name** | **Description** |
| `filename` | `str` The path to the service account private key json file. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `ManagedSchemaRegistryClient` | The constructed client. |

### from_service_account_info

    from_service_account_info(info: dict, *args, **kwargs)

Creates an instance of this client using the provided credentials
info.

| **Parameter** ||
|---|---|
| **Name** | **Description** |
| `info` | `dict` The service account private key info. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `ManagedSchemaRegistryClient` | The constructed client. |

### from_service_account_json

    from_service_account_json(filename: str, *args, **kwargs)

Creates an instance of this client using the provided credentials
file.

| **Parameter** ||
|---|---|
| **Name** | **Description** |
| `filename` | `str` The path to the service account private key json file. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `ManagedSchemaRegistryClient` | The constructed client. |

### get_context

    get_context(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.GetContextRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.Context
    )

Get the context.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_get_context():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetContextRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_get_context(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetContextRequest, dict]` The request object. Request for GetContext |
| `name` | `str` Required. The name of the context to return. Structured like: `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}` This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.Context` | Context represents an independent schema grouping in a schema registry instance. |

### get_location

    get_location(
        request: typing.Optional[
            typing.Union[google.cloud.location.locations_pb2.GetLocationRequest, dict]
        ] = None,
        *,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.cloud.location.locations_pb2.Location

Gets information about a location.

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `` `.location_pb2.GetLocationRequest` `` The request object. Request message for `GetLocation` method. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `` `.location_pb2.Location` `` | Location object. |

### get_mtls_endpoint_and_cert_source

    get_mtls_endpoint_and_cert_source(
        client_options: typing.Optional[
            google.api_core.client_options.ClientOptions
        ] = None,
    )

Deprecated. Return the API endpoint and client cert source for mutual TLS.

The client cert source is determined in the following order:
(1) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is not "true", the
client cert source is None.
(2) if `client_options.client_cert_source` is provided, use the provided one; if the
default client cert source exists, use the default one; otherwise the client cert
source is None.

The API endpoint is determined in the following order:
(1) if `client_options.api_endpoint` if provided, use the provided one.
(2) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is "always", use the
default mTLS endpoint; if the environment variable is "never", use the default API
endpoint; otherwise if client cert source exists, use the default mTLS endpoint, otherwise
use the default API endpoint.

More details can be found at <https://google.aip.dev/auth/4114>.

| **Parameter** ||
|---|---|
| **Name** | **Description** |
| `client_options` | `google.api_core.client_options.ClientOptions` Custom options for the client. Only the `api_endpoint` and `client_cert_source` properties may be used in this method. |

| **Exceptions** ||
|---|---|
| **Type** | **Description** |
| `google.auth.exceptions.MutualTLSChannelError` | If any errors happen. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `Tuple[str, Callable[[], Tuple[bytes, bytes]]]` | returns the API endpoint and the client cert source to use. |

### get_operation

    get_operation(
        request: typing.Optional[
            typing.Union[google.longrunning.operations_pb2.GetOperationRequest, dict]
        ] = None,
        *,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.longrunning.operations_pb2.Operation

Gets the latest state of a long-running operation.

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `` `.operations_pb2.GetOperationRequest` `` The request object. Request message for `GetOperation` method. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `` `.operations_pb2.Operation` `` | An `Operation` object. |

### get_raw_schema

    get_raw_schema(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.GetSchemaRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.api.httpbody_pb2.HttpBody

Get the schema string for the given schema id.
The response will be the schema string.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_get_raw_schema():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetSchemaRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_get_raw_schema(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetSchemaRequest, dict]` The request object. Request for GetSchema. |
| `name` | `str` Required. The name of the schema to return. Structured like: `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}` This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `google.api.httpbody_pb2.HttpBody` | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. |

### get_raw_schema_version

    get_raw_schema_version(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.GetVersionRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.api.httpbody_pb2.HttpBody

Get the schema string only for a version of a
subject. The response will be the schema string.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_get_raw_schema_version():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetVersionRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_get_raw_schema_version(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetVersionRequest, dict]` The request object. Request for GetVersion. |
| `name` | `str` Required. 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}` This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `google.api.httpbody_pb2.HttpBody` | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. |

### get_schema

    get_schema(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.GetSchemaRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.Schema

Get the schema for the given schema id.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_get_schema():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetSchemaRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_get_schema(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetSchemaRequest, dict]` The request object. Request for GetSchema. |
| `name` | `str` Required. The name of the schema to return. Structured like: `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}` This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.Schema` | Schema for a Kafka message. |

### get_schema_config

    get_schema_config(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.GetSchemaConfigRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaConfig
    )

Get schema config at global level or for a subject.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_get_schema_config():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetSchemaConfigRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_get_schema_config(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetSchemaConfigRequest, dict]` The request object. Request for getting config. |
| `name` | `str` Required. 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. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaConfig` | SchemaConfig represents configuration for a schema registry or a specific subject. |

### get_schema_mode

    get_schema_mode(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.GetSchemaModeRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaMode
    )

Get mode at global level or for a subject.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_get_schema_mode():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetSchemaModeRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_get_schema_mode(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetSchemaModeRequest, dict]` The request object. Request for getting schema registry or subject mode. |
| `name` | `str` Required. 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 This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaMode` | SchemaMode represents the mode of a schema registry or a specific subject. Four modes are supported: \\\* NONE: deprecated. This was the default mode for a subject, but now the default is unset (which means use the global schema registry setting) \\\* READONLY: The schema registry is in read-only mode. \\\* READWRITE: The schema registry is in read-write mode, which allows limited write operations on the schema. \\\* IMPORT: The schema registry is in import mode, which allows more editing operations on the schema for data importing purposes. |

### get_schema_registry

    get_schema_registry(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.GetSchemaRegistryRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaRegistry
    )

Get the schema registry instance.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_get_schema_registry():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetSchemaRegistryRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_get_schema_registry(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetSchemaRegistryRequest, dict]` The request object. Request for GetSchemaRegistry. |
| `name` | `str` Required. The name of the schema registry instance to return. Structured like: `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}` This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaRegistry` | SchemaRegistry is a schema registry instance. |

### get_version

    get_version(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.GetVersionRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaVersion
    )

Get a versioned schema (schema with subject/version)
of a subject.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_get_version():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetVersionRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_get_version(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.GetVersionRequest, dict]` The request object. Request for GetVersion. |
| `name` | `str` Required. 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}` This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaVersion` | Version of a schema. |

### list_contexts

    list_contexts(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.ListContextsRequest,
                dict,
            ]
        ] = None,
        *,
        parent: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.api.httpbody_pb2.HttpBody

List contexts for a schema registry.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_list_contexts():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListContextsRequest.html(
            parent="parent_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_list_contexts(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListContextsRequest, dict]` The request object. Request for ListContexts. |
| `parent` | `str` Required. The parent of the contexts. Structured like: `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}` This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `google.api.httpbody_pb2.HttpBody` | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. |

### list_locations

    list_locations(
        request: typing.Optional[
            typing.Union[google.cloud.location.locations_pb2.ListLocationsRequest, dict]
        ] = None,
        *,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.cloud.location.locations_pb2.ListLocationsResponse

Lists information about the supported locations for this service.

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `` `.location_pb2.ListLocationsRequest` `` The request object. Request message for `ListLocations` method. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `` `.location_pb2.ListLocationsResponse` `` | Response message for `ListLocations` method. |

### list_operations

    list_operations(
        request: typing.Optional[
            typing.Union[google.longrunning.operations_pb2.ListOperationsRequest, dict]
        ] = None,
        *,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.longrunning.operations_pb2.ListOperationsResponse

Lists operations that match the specified filter in the request.

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `` `.operations_pb2.ListOperationsRequest` `` The request object. Request message for `ListOperations` method. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `` `.operations_pb2.ListOperationsResponse` `` | Response message for `ListOperations` method. |

### list_referenced_schemas

    list_referenced_schemas(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.ListReferencedSchemasRequest,
                dict,
            ]
        ] = None,
        *,
        parent: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.api.httpbody_pb2.HttpBody

Get a list of IDs of schemas that reference the
schema with the given subject and version.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_list_referenced_schemas():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListReferencedSchemasRequest.html(
            parent="parent_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_list_referenced_schemas(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListReferencedSchemasRequest, dict]` The request object. Request for ListReferencedSchemas. |
| `parent` | `str` Required. 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}` This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `google.api.httpbody_pb2.HttpBody` | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. |

### list_schema_registries

    list_schema_registries(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.ListSchemaRegistriesRequest,
                dict,
            ]
        ] = None,
        *,
        parent: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.ListSchemaRegistriesResponse
    )

List schema registries.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_list_schema_registries():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListSchemaRegistriesRequest.html(
            parent="parent_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_list_schema_registries(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListSchemaRegistriesRequest, dict]` The request object. Request for ListSchemaRegistries. |
| `parent` | `str` Required. The parent whose schema registry instances are to be listed. Structured like: `projects/{project}/locations/{location}` This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListSchemaRegistriesResponse` | Request for ListSchemaRegistries. |

### list_schema_types

    list_schema_types(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.ListSchemaTypesRequest,
                dict,
            ]
        ] = None,
        *,
        parent: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.api.httpbody_pb2.HttpBody

List the supported schema types.
The response will be an array of schema types.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_list_schema_types():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListSchemaTypesRequest.html(
            parent="parent_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_list_schema_types(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListSchemaTypesRequest, dict]` The request object. Request for ListSchemaTypes. |
| `parent` | `str` Required. The parent schema registry whose schema types are to be listed. Structured like: `projects/{project}/locations/{location}/schemaRegistries/{schema_registry}` This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `google.api.httpbody_pb2.HttpBody` | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. |

### list_schema_versions

    list_schema_versions(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.ListSchemaVersionsRequest,
                dict,
            ]
        ] = None,
        *,
        parent: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.api.httpbody_pb2.HttpBody

List the schema versions for the given schema id. The response
will be an array of subject-version pairs as:
\[{"subject":"subject1", "version":1}, {"subject":"subject2",
"version":2}\].

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_list_schema_versions():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListSchemaVersionsRequest.html(
            parent="parent_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_list_schema_versions(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListSchemaVersionsRequest, dict]` The request object. Request for ListSchemaVersions. |
| `parent` | `str` Required. 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}` This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `google.api.httpbody_pb2.HttpBody` | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. |

### list_subjects

    list_subjects(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.ListSubjectsRequest,
                dict,
            ]
        ] = None,
        *,
        parent: typing.Optional[str] = None,
        subject_prefix: typing.Optional[str] = None,
        deleted: typing.Optional[bool] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.api.httpbody_pb2.HttpBody

List subjects in the schema registry.
The response will be an array of subject names.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_list_subjects():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListSubjectsRequest.html(
            parent="parent_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_list_subjects(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListSubjectsRequest, dict]` The request object. Request for listing subjects. |
| `parent` | `str` Required. 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}` This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set. |
| `subject_prefix` | `str` Optional. The context to filter the subjects by, in the format of `:.{context}:`. If unset, all subjects in the registry are returned. Set to empty string or add as '?subjectPrefix=' at the end of this request to list subjects in the default context. This corresponds to the `subject_prefix` field on the `request` instance; if `request` is provided, this should not be set. |
| `deleted` | `bool` Optional. If true, the response will include soft-deleted subjects. The default is false. This corresponds to the `deleted` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `google.api.httpbody_pb2.HttpBody` | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. |

### list_subjects_by_schema_id

    list_subjects_by_schema_id(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.ListSubjectsBySchemaIdRequest,
                dict,
            ]
        ] = None,
        *,
        parent: typing.Optional[str] = None,
        subject: typing.Optional[str] = None,
        deleted: typing.Optional[bool] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.api.httpbody_pb2.HttpBody

List subjects which reference a particular schema id.
The response will be an array of subject names.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_list_subjects_by_schema_id():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListSubjectsBySchemaIdRequest.html(
            parent="parent_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_list_subjects_by_schema_id(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListSubjectsBySchemaIdRequest, dict]` The request object. Request for listing subjects. |
| `parent` | `str` Required. 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}` This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set. |
| `subject` | `str` Optional. The subject to filter the subjects by. This corresponds to the `subject` field on the `request` instance; if `request` is provided, this should not be set. |
| `deleted` | `bool` Optional. If true, the response will include soft-deleted subjects. The default is false. This corresponds to the `deleted` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `google.api.httpbody_pb2.HttpBody` | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. |

### list_versions

    list_versions(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.ListVersionsRequest,
                dict,
            ]
        ] = None,
        *,
        parent: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> google.api.httpbody_pb2.HttpBody

Get all versions of a subject.
The response will be an array of versions of the
subject.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_list_versions():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListVersionsRequest.html(
            parent="parent_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_list_versions(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.ListVersionsRequest, dict]` The request object. Request for GetVersions. |
| `parent` | `str` Required. 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}` This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `google.api.httpbody_pb2.HttpBody` | Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged. |

### lookup_version

    lookup_version(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.LookupVersionRequest,
                dict,
            ]
        ] = None,
        *,
        parent: typing.Optional[str] = None,
        schema: typing.Optional[str] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaVersion
    )

Lookup a schema under the specified subject.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_lookup_version():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.LookupVersionRequest.html(
            parent="parent_value",
            schema="schema_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_lookup_version(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.LookupVersionRequest, dict]` The request object. Request for LookupVersion. |
| `parent` | `str` Required. 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}` This corresponds to the `parent` field on the `request` instance; if `request` is provided, this should not be set. |
| `schema` | `str` Required. The schema payload This corresponds to the `schema` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaVersion` | Version of a schema. |

### parse_common_billing_account_path

    parse_common_billing_account_path(path: str) -> typing.Dict[str, str]

Parse a billing_account path into its component segments.

### parse_common_folder_path

    parse_common_folder_path(path: str) -> typing.Dict[str, str]

Parse a folder path into its component segments.

### parse_common_location_path

    parse_common_location_path(path: str) -> typing.Dict[str, str]

Parse a location path into its component segments.

### parse_common_organization_path

    parse_common_organization_path(path: str) -> typing.Dict[str, str]

Parse a organization path into its component segments.

### parse_common_project_path

    parse_common_project_path(path: str) -> typing.Dict[str, str]

Parse a project path into its component segments.

### parse_schema_config_path

    parse_schema_config_path(path: str) -> typing.Dict[str, str]

Parses a schema_config path into its component segments.

### parse_schema_context_path

    parse_schema_context_path(path: str) -> typing.Dict[str, str]

Parses a schema_context path into its component segments.

### parse_schema_mode_path

    parse_schema_mode_path(path: str) -> typing.Dict[str, str]

Parses a schema_mode path into its component segments.

### parse_schema_path

    parse_schema_path(path: str) -> typing.Dict[str, str]

Parses a schema path into its component segments.

### parse_schema_registry_path

    parse_schema_registry_path(path: str) -> typing.Dict[str, str]

Parses a schema_registry path into its component segments.

### parse_schema_subject_path

    parse_schema_subject_path(path: str) -> typing.Dict[str, str]

Parses a schema_subject path into its component segments.

### parse_schema_version_path

    parse_schema_version_path(path: str) -> typing.Dict[str, str]

Parses a schema_version path into its component segments.

### schema_config_path

    schema_config_path(project: str, location: str, schema_registry: str) -> str

Returns a fully-qualified schema_config string.

### schema_context_path

    schema_context_path(
        project: str, location: str, schema_registry: str, context: str
    ) -> str

Returns a fully-qualified schema_context string.

### schema_mode_path

    schema_mode_path(project: str, location: str, schema_registry: str) -> str

Returns a fully-qualified schema_mode string.

### schema_path

    schema_path(project: str, location: str, schema_registry: str, schema: str) -> str

Returns a fully-qualified schema string.

### schema_registry_path

    schema_registry_path(project: str, location: str, schema_registry: str) -> str

Returns a fully-qualified schema_registry string.

### schema_subject_path

    schema_subject_path(
        project: str, location: str, schema_registry: str, subject: str
    ) -> str

Returns a fully-qualified schema_subject string.

### schema_version_path

    schema_version_path(
        project: str, location: str, schema_registry: str, subject: str, version: str
    ) -> str

Returns a fully-qualified schema_version string.

### update_schema_config

    update_schema_config(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.UpdateSchemaConfigRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        compatibility: typing.Optional[
            google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaConfig.CompatibilityType
        ] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaConfig
    )

Update config at global level or for a subject.
Creates a SchemaSubject-level SchemaConfig if it does
not exist.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_update_schema_config():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.UpdateSchemaConfigRequest.html(
            name="name_value",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_update_schema_config(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.UpdateSchemaConfigRequest, dict]` The request object. Request for updating schema config. On a SchemaSubject-level SchemaConfig, an unset field will be removed from the SchemaConfig. |
| `name` | `str` Required. 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. This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `compatibility` | `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaConfig.CompatibilityType` Required. 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. This corresponds to the `compatibility` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaConfig` | SchemaConfig represents configuration for a schema registry or a specific subject. |

### update_schema_mode

    update_schema_mode(
        request: typing.Optional[
            typing.Union[
                google.cloud.managedkafka_schemaregistry_v1.types.schema_registry.UpdateSchemaModeRequest,
                dict,
            ]
        ] = None,
        *,
        name: typing.Optional[str] = None,
        mode: typing.Optional[
            google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaMode.ModeType
        ] = None,
        retry: typing.Optional[
            typing.Union[
                google.api_core.retry.retry_unary.Retry,
                google.api_core.gapic_v1.method._MethodDefault,
            ]
        ] = _MethodDefault._DEFAULT_VALUE,
        timeout: typing.Union[float, object] = _MethodDefault._DEFAULT_VALUE,
        metadata: typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]] = ()
    ) -> (
        google.cloud.managedkafka_schemaregistry_v1.types.schema_registry_resources.SchemaMode
    )

Update mode at global level or for a subject.

    # This snippet 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 as shown in:
    #   https://googleapis.dev/python/google-api-core/latest/client_options.html
    from google.cloud import https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest

    def sample_update_schema_mode():
        # Create a client
        client = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html()

        # Initialize request argument(s)
        request = https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.UpdateSchemaModeRequest.html(
            name="name_value",
            mode="IMPORT",
        )

        # Make the request
        response = client.https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.services.managed_schema_registry.ManagedSchemaRegistryClient.html#google_cloud_managedkafka_schemaregistry_v1_services_managed_schema_registry_ManagedSchemaRegistryClient_update_schema_mode(request=request)

        # Handle the response
        print(response)

| **Parameters** ||
|---|---|
| **Name** | **Description** |
| `request` | `Union[https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.UpdateSchemaModeRequest, dict]` The request object. Request for updating schema registry or subject mode. |
| `name` | `str` Required. 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 This corresponds to the `name` field on the `request` instance; if `request` is provided, this should not be set. |
| `mode` | `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaMode.ModeType` Required. The mode type. This corresponds to the `mode` field on the `request` instance; if `request` is provided, this should not be set. |
| `retry` | `google.api_core.retry.Retry` Designation of what errors, if any, should be retried. |
| `timeout` | `float` The timeout for this request. |
| `metadata` | `Sequence[Tuple[str, Union[str, bytes]]]` Key/value pairs which should be sent along with the request as metadata. Normally, each value must be of type `str`, but for metadata keys ending with the suffix `-bin`, the corresponding values must be of type `bytes`. |

| **Returns** ||
|---|---|
| **Type** | **Description** |
| `https://docs.cloud.google.com/python/docs/reference/google-cloud-managedkafka-schemaregistry/latest/google.cloud.managedkafka_schemaregistry_v1.types.SchemaMode` | SchemaMode represents the mode of a schema registry or a specific subject. Four modes are supported: \\\* NONE: deprecated. This was the default mode for a subject, but now the default is unset (which means use the global schema registry setting) \\\* READONLY: The schema registry is in read-only mode. \\\* READWRITE: The schema registry is in read-write mode, which allows limited write operations on the schema. \\\* IMPORT: The schema registry is in import mode, which allows more editing operations on the schema for data importing purposes. |