Class: Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client

Inherits:

Object

Object
Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client

show all

Includes:: Paths

Defined in:: lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb

Overview

Client for the ManagedSchemaRegistry service.

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.

Defined Under Namespace

Classes: Configuration

Instance Attribute Summary collapse

#location_client ⇒ Google::Cloud::Location::Locations::Client readonly
Get the associated client for mix-in of the Locations.

Class Method Summary collapse

.configure {|config| ... } ⇒ Client::Configuration
Configure the ManagedSchemaRegistry Client class.

Instance Method Summary collapse

#check_compatibility(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CheckCompatibilityResponse
Check compatibility of a schema with all versions or a specific version of a subject.
#configure {|config| ... } ⇒ Client::Configuration
Configure the ManagedSchemaRegistry Client instance.
#create_schema_registry(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry
Create a schema registry instance.
#create_version(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateVersionResponse
Register a new version under a given subject with the given schema.
#delete_schema_config(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig
Delete schema config for a subject.
#delete_schema_mode(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode
Delete schema mode for a subject.
#delete_schema_registry(request, options = nil) {|response, operation| ... } ⇒ ::Google::Protobuf::Empty
Delete a schema registry instance.
#delete_subject(request, options = nil) {|response, operation| ... } ⇒ ::Google::Api::HttpBody
Delete a subject.
#delete_version(request, options = nil) {|response, operation| ... } ⇒ ::Google::Api::HttpBody
Delete a version of a subject.
#get_context(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context
Get the context.
#get_raw_schema(request, options = nil) {|response, operation| ... } ⇒ ::Google::Api::HttpBody
Get the schema string for the given schema id.
#get_raw_schema_version(request, options = nil) {|response, operation| ... } ⇒ ::Google::Api::HttpBody
Get the schema string only for a version of a subject.
#get_schema(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema
Get the schema for the given schema id.
#get_schema_config(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig
Get schema config at global level or for a subject.
#get_schema_mode(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode
Get mode at global level or for a subject.
#get_schema_registry(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry
Get the schema registry instance.
#get_version(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion
Get a versioned schema (schema with subject/version) of a subject.
#initialize {|config| ... } ⇒ Client constructor
Create a new ManagedSchemaRegistry client object.
#list_contexts(request, options = nil) {|response, operation| ... } ⇒ ::Google::Api::HttpBody
List contexts for a schema registry.
#list_referenced_schemas(request, options = nil) {|response, operation| ... } ⇒ ::Google::Api::HttpBody
Get a list of IDs of schemas that reference the schema with the given subject and version.
#list_schema_registries(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse
List schema registries.
#list_schema_types(request, options = nil) {|response, operation| ... } ⇒ ::Google::Api::HttpBody
List the supported schema types.
#list_schema_versions(request, options = nil) {|response, operation| ... } ⇒ ::Google::Api::HttpBody
List the schema versions for the given schema id.
#list_subjects(request, options = nil) {|response, operation| ... } ⇒ ::Google::Api::HttpBody
List subjects in the schema registry.
#list_subjects_by_schema_id(request, options = nil) {|response, operation| ... } ⇒ ::Google::Api::HttpBody
List subjects which reference a particular schema id.
#list_versions(request, options = nil) {|response, operation| ... } ⇒ ::Google::Api::HttpBody
Get all versions of a subject.
#logger ⇒ Logger
The logger used for request/response debug logging.
#lookup_version(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion
Lookup a schema under the specified subject.
#universe_domain ⇒ String
The effective universe domain.
#update_schema_config(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig
Update config at global level or for a subject.
#update_schema_mode(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode
Update mode at global level or for a subject.

Methods included from Paths

#schema_config_path, #schema_context_path, #schema_mode_path, #schema_path, #schema_registry_path, #schema_subject_path, #schema_version_path

Constructor Details

#initialize {|config| ... } ⇒ `Client`

Create a new ManagedSchemaRegistry client object.

Examples:


# Create a client using the default configuration
client = ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a client using a custom configuration
client = ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new do |config|
  config.timeout = 10.0
end

Yields:

(config) —
Configure the ManagedSchemaRegistry client.

Yield Parameters:

config (Client::Configuration)

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 174

def initialize
  # These require statements are intentionally placed here to initialize
  # the gRPC module only when it's required.
  # See https://github.com/googleapis/toolkit/issues/446
  require "gapic/grpc"
  require "google/cloud/managedkafka/schemaregistry/v1/schema_registry_services_pb"

  # Create the configuration object
  @config = Configuration.new Client.configure

  # Yield the configuration if needed
  yield @config if block_given?

  # Create credentials
  credentials = @config.credentials
  # Use self-signed JWT if the endpoint is unchanged from default,
  # but only if the default endpoint does not have a region prefix.
  enable_self_signed_jwt = @config.endpoint.nil? ||
                           (@config.endpoint == Configuration::DEFAULT_ENDPOINT &&
                           !@config.endpoint.split(".").first.include?("-"))
  credentials ||= Credentials.default scope: @config.scope,
                                      enable_self_signed_jwt: enable_self_signed_jwt
  if credentials.is_a?(::String) || credentials.is_a?(::Hash)
    credentials = Credentials.new credentials, scope: @config.scope
  end
  @quota_project_id = @config.quota_project
  @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id

  @managed_schema_registry_stub = ::Gapic::ServiceStub.new(
    ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Stub,
    credentials: credentials,
    endpoint: @config.endpoint,
    endpoint_template: DEFAULT_ENDPOINT_TEMPLATE,
    universe_domain: @config.universe_domain,
    channel_args: @config.channel_args,
    interceptors: @config.interceptors,
    channel_pool_config: @config.channel_pool,
    logger: @config.logger
  )

  @managed_schema_registry_stub.stub_logger&.info do |entry|
    entry.set_system_name
    entry.set_service
    entry.message = "Created client for #{entry.service}"
    entry.set_credentials_fields credentials
    entry.set "customEndpoint", @config.endpoint if @config.endpoint
    entry.set "defaultTimeout", @config.timeout if @config.timeout
    entry.set "quotaProject", @quota_project_id if @quota_project_id
  end

  @location_client = Google::Cloud::Location::Locations::Client.new do |config|
    config.credentials = credentials
    config.quota_project = @quota_project_id
    config.endpoint = @managed_schema_registry_stub.endpoint
    config.universe_domain = @managed_schema_registry_stub.universe_domain
    config.logger = @managed_schema_registry_stub.logger if config.respond_to? :logger=
  end
end

Instance Attribute Details

#location_client ⇒ `Google::Cloud::Location::Locations::Client` (readonly)

Get the associated client for mix-in of the Locations.

Returns:

(Google::Cloud::Location::Locations::Client)



238
239
240

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 238

def location_client
  @location_client
end

Class Method Details

.configure {|config| ... } ⇒ `Client::Configuration`

Configure the ManagedSchemaRegistry Client class.

See Configuration for a description of the configuration fields.

Examples:


# Modify the configuration for all ManagedSchemaRegistry clients
::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.configure do |config|
  config.timeout = 10.0
end

Yields:

(config) —
Configure the Client client.

Yield Parameters:

config (Client::Configuration)

Returns:

(Client::Configuration)

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 112

def self.configure
  @configure ||= begin
    namespace = ["Google", "Cloud", "ManagedKafka", "SchemaRegistry", "V1"]
    parent_config = while namespace.any?
                      parent_name = namespace.join "::"
                      parent_const = const_get parent_name
                      break parent_const.configure if parent_const.respond_to? :configure
                      namespace.pop
                    end
    default_config = Client::Configuration.new parent_config

    default_config
  end
  yield @configure if block_given?
  @configure
end

Instance Method Details

#check_compatibility(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CheckCompatibilityResponse` #check_compatibility(name: nil, schema_type: nil, schema: nil, references: nil, verbose: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CheckCompatibilityResponse`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::CheckCompatibilityRequest.new

# Call the check_compatibility method.
result = client.check_compatibility request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::CheckCompatibilityResponse.
p result

Overloads:

#check_compatibility(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CheckCompatibilityResponse

Pass arguments to check_compatibility via a request object, either of type CheckCompatibilityRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CheckCompatibilityRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#check_compatibility(name: nil, schema_type: nil, schema: nil, references: nil, verbose: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CheckCompatibilityResponse

Pass arguments to check_compatibility via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  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.
- schema_type (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema::SchemaType) (defaults to: nil) —
  Optional. The schema type of the schema.
- schema (::String) (defaults to: nil) —
  Required. The schema payload
- references (::Array<::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema::SchemaReference, ::Hash>) (defaults to: nil) —
  Optional. The schema references used by the schema.
- verbose (::Boolean) (defaults to: nil) —
  Optional. If true, the response will contain the compatibility check result with reasons for failed checks. The default is false.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CheckCompatibilityResponse)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CheckCompatibilityResponse)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 2159

def check_compatibility request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CheckCompatibilityRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.check_compatibility.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.check_compatibility.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.check_compatibility.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :check_compatibility, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#configure {|config| ... } ⇒ `Client::Configuration`

Configure the ManagedSchemaRegistry Client instance.

The configuration is set to the derived mode, meaning that values can be changed, but structural changes (adding new fields, etc.) are not allowed. Structural changes should be made on configure.

See Configuration for a description of the configuration fields.

Yields:

(config) —
Configure the Client client.

Yield Parameters:

config (Client::Configuration)

Returns:

(Client::Configuration)

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 144

def configure
  yield @config if block_given?
  @config
end

#create_schema_registry(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry` #create_schema_registry(parent: nil, schema_registry_id: nil, schema_registry: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry`

Create a schema registry instance.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateSchemaRegistryRequest.new

# Call the create_schema_registry method.
result = client.create_schema_registry request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry.
p result

Overloads:

#create_schema_registry(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry

Pass arguments to create_schema_registry via a request object, either of type CreateSchemaRegistryRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateSchemaRegistryRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_schema_registry(parent: nil, schema_registry_id: nil, schema_registry: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry

Pass arguments to create_schema_registry via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The parent whose schema registry instance is to be created. Structured like: projects/{project}/locations/{location}
- schema_registry_id (::String) (defaults to: nil) —
  Required. The schema registry instance ID to use for this schema registry. The ID must contain only letters (a-z, A-Z), numbers (0-9), and underscores (-). The maximum length is 63 characters. The ID must not start with a number.
- schema_registry (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry, ::Hash) (defaults to: nil) —
  Required. The schema registry instance to create. The name field is ignored.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 477

def create_schema_registry request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateSchemaRegistryRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.create_schema_registry.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.create_schema_registry.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_schema_registry.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :create_schema_registry, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#create_version(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateVersionResponse` #create_version(parent: nil, version: nil, id: nil, schema_type: nil, schema: nil, references: nil, normalize: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateVersionResponse`

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateVersionRequest.new

# Call the create_version method.
result = client.create_version request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateVersionResponse.
p result

Overloads:

#create_version(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateVersionResponse

Pass arguments to create_version via a request object, either of type CreateVersionRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateVersionRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_version(parent: nil, version: nil, id: nil, schema_type: nil, schema: nil, references: nil, normalize: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateVersionResponse

Pass arguments to create_version via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- parent (::String) (defaults to: nil) —
  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}
- version (::Integer) (defaults to: nil) —
  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.
- id (::Integer) (defaults to: nil) —
  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.
- schema_type (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema::SchemaType) (defaults to: nil) —
  Optional. The type of the schema. It is optional. If not specified, the schema type will be AVRO.
- schema (::String) (defaults to: nil) —
  Required. The schema payload
- references (::Array<::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema::SchemaReference, ::Hash>) (defaults to: nil) —
  Optional. The schema references used by the schema.
- normalize (::Boolean) (defaults to: nil) —
  Optional. If true, the schema will be normalized before being stored. The default is false.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateVersionResponse)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateVersionResponse)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 1875

def create_version request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::CreateVersionRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.create_version.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.create_version.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_version.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :create_version, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#delete_schema_config(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig` #delete_schema_config(name: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig`

Delete schema config for a subject.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSchemaConfigRequest.new

# Call the delete_schema_config method.
result = client.delete_schema_config request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig.
p result

Overloads:

#delete_schema_config(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig

Pass arguments to delete_schema_config via a request object, either of type DeleteSchemaConfigRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSchemaConfigRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_schema_config(name: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig

Pass arguments to delete_schema_config via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The resource name of subject to delete the config for. The format is
  - projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/config/{subject}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 2436

def delete_schema_config request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSchemaConfigRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.delete_schema_config.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.delete_schema_config.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_schema_config.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :delete_schema_config, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#delete_schema_mode(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode` #delete_schema_mode(name: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode`

Delete schema mode for a subject.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSchemaModeRequest.new

# Call the delete_schema_mode method.
result = client.delete_schema_mode request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode.
p result

Overloads:

#delete_schema_mode(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode

Pass arguments to delete_schema_mode via a request object, either of type DeleteSchemaModeRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSchemaModeRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_schema_mode(name: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode

Pass arguments to delete_schema_mode via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  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}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 2700

def delete_schema_mode request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSchemaModeRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.delete_schema_mode.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.delete_schema_mode.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_schema_mode.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :delete_schema_mode, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#delete_schema_registry(request, options = nil) ⇒ `::Google::Protobuf::Empty` #delete_schema_registry(name: nil) ⇒ `::Google::Protobuf::Empty`

Delete a schema registry instance.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSchemaRegistryRequest.new

# Call the delete_schema_registry method.
result = client.delete_schema_registry request

# The returned object is of type Google::Protobuf::Empty.
p result

Overloads:

#delete_schema_registry(request, options = nil) ⇒ ::Google::Protobuf::Empty

Pass arguments to delete_schema_registry via a request object, either of type DeleteSchemaRegistryRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSchemaRegistryRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_schema_registry(name: nil) ⇒ ::Google::Protobuf::Empty

Pass arguments to delete_schema_registry via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The name of the schema registry instance to delete. Structured like: projects/{project}/locations/{location}/schemaRegistries/{schema_registry}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Protobuf::Empty)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Protobuf::Empty)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 564

def delete_schema_registry request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSchemaRegistryRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.delete_schema_registry.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.delete_schema_registry.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_schema_registry.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :delete_schema_registry, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#delete_subject(request, options = nil) ⇒ `::Google::Api::HttpBody` #delete_subject(name: nil, permanent: nil) ⇒ `::Google::Api::HttpBody`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSubjectRequest.new

# Call the delete_subject method.
result = client.delete_subject request

# The returned object is of type Google::Api::HttpBody.
p result

Overloads:

#delete_subject(request, options = nil) ⇒ ::Google::Api::HttpBody

Pass arguments to delete_subject via a request object, either of type DeleteSubjectRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSubjectRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_subject(name: nil, permanent: nil) ⇒ ::Google::Api::HttpBody

Pass arguments to delete_subject via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  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}
- permanent (::Boolean) (defaults to: nil) —
  Optional. If true, the subject and all associated metadata including the schema ID will be deleted permanently. Otherwise, only the subject is soft-deleted. The default is false. Soft-deleted subjects can still be searched in ListSubjects API call with deleted=true query parameter. A soft-delete of a subject must be performed before a hard-delete.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Api::HttpBody)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Api::HttpBody)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 1390

def delete_subject request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteSubjectRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.delete_subject.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.delete_subject.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_subject.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :delete_subject, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#delete_version(request, options = nil) ⇒ `::Google::Api::HttpBody` #delete_version(name: nil, permanent: nil) ⇒ `::Google::Api::HttpBody`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteVersionRequest.new

# Call the delete_version method.
result = client.delete_version request

# The returned object is of type Google::Api::HttpBody.
p result

Overloads:

#delete_version(request, options = nil) ⇒ ::Google::Api::HttpBody

Pass arguments to delete_version via a request object, either of type DeleteVersionRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteVersionRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_version(name: nil, permanent: nil) ⇒ ::Google::Api::HttpBody

Pass arguments to delete_version via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  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}
- permanent (::Boolean) (defaults to: nil) —
  Optional. If true, both the version and the referenced schema ID will be permanently deleted. The default is false. If false, the version will be deleted but the schema ID will be retained. Soft-deleted versions can still be searched in ListVersions API call with deleted=true query parameter. A soft-delete of a version must be performed before a hard-delete.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Api::HttpBody)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Api::HttpBody)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 1970

def delete_version request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::DeleteVersionRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.delete_version.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.delete_version.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_version.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :delete_version, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_context(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context` #get_context(name: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context`

Get the context.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetContextRequest.new

# Call the get_context method.
result = client.get_context request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context.
p result

Overloads:

#get_context(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context

Pass arguments to get_context via a request object, either of type GetContextRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetContextRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_context(name: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context

Pass arguments to get_context via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The name of the context to return. Structured like: projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/contexts/{context}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 650

def get_context request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetContextRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_context.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_context.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_context.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :get_context, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_raw_schema(request, options = nil) ⇒ `::Google::Api::HttpBody` #get_raw_schema(name: nil, subject: nil) ⇒ `::Google::Api::HttpBody`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaRequest.new

# Call the get_raw_schema method.
result = client.get_raw_schema request

# The returned object is of type Google::Api::HttpBody.
p result

Overloads:

#get_raw_schema(request, options = nil) ⇒ ::Google::Api::HttpBody

Pass arguments to get_raw_schema via a request object, either of type GetSchemaRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_raw_schema(name: nil, subject: nil) ⇒ ::Google::Api::HttpBody

Pass arguments to get_raw_schema via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The name of the schema to return. Structured like: projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}
- subject (::String) (defaults to: nil) —
  Optional. Used to limit the search for the schema ID to a specific subject, otherwise the schema ID will be searched for in all subjects in the given specified context.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Api::HttpBody)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Api::HttpBody)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 917

def get_raw_schema request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_raw_schema.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_raw_schema.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_raw_schema.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :get_raw_schema, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_raw_schema_version(request, options = nil) ⇒ `::Google::Api::HttpBody` #get_raw_schema_version(name: nil, deleted: nil) ⇒ `::Google::Api::HttpBody`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetVersionRequest.new

# Call the get_raw_schema_version method.
result = client.get_raw_schema_version request

# The returned object is of type Google::Api::HttpBody.
p result

Overloads:

#get_raw_schema_version(request, options = nil) ⇒ ::Google::Api::HttpBody

Pass arguments to get_raw_schema_version via a request object, either of type GetVersionRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetVersionRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_raw_schema_version(name: nil, deleted: nil) ⇒ ::Google::Api::HttpBody

Pass arguments to get_raw_schema_version via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  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}
- deleted (::Boolean) (defaults to: nil) —
  Optional. If true, no matter if the subject/version is soft-deleted or not, it returns the version details. If false, it returns NOT_FOUND error if the subject/version is soft-deleted. The default is false.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Api::HttpBody)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Api::HttpBody)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 1676

def get_raw_schema_version request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetVersionRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_raw_schema_version.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_raw_schema_version.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_raw_schema_version.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :get_raw_schema_version, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_schema(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema` #get_schema(name: nil, subject: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema`

Get the schema for the given schema id.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaRequest.new

# Call the get_schema method.
result = client.get_schema request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema.
p result

Overloads:

#get_schema(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema

Pass arguments to get_schema via a request object, either of type GetSchemaRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_schema(name: nil, subject: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema

Pass arguments to get_schema via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The name of the schema to return. Structured like: projects/{project}/locations/{location}/schemaRegistries/{schema_registry}/schemas/ids/{schema}
- subject (::String) (defaults to: nil) —
  Optional. Used to limit the search for the schema ID to a specific subject, otherwise the schema ID will be searched for in all subjects in the given specified context.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 826

def get_schema request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_schema.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_schema.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_schema.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :get_schema, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_schema_config(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig` #get_schema_config(name: nil, default_to_global: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig`

Get schema config at global level or for a subject.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaConfigRequest.new

# Call the get_schema_config method.
result = client.get_schema_config request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig.
p result

Overloads:

#get_schema_config(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig

Pass arguments to get_schema_config via a request object, either of type GetSchemaConfigRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaConfigRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_schema_config(name: nil, default_to_global: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig

Pass arguments to get_schema_config via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  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.
- default_to_global (::Boolean) (defaults to: nil) —
  Optional. If true, the config will fall back to the config at the global level if no subject level config is found.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 2250

def get_schema_config request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaConfigRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_schema_config.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_schema_config.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_schema_config.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :get_schema_config, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_schema_mode(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode` #get_schema_mode(name: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode`

Get mode at global level or for a subject.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaModeRequest.new

# Call the get_schema_mode method.
result = client.get_schema_mode request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode.
p result

Overloads:

#get_schema_mode(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode

Pass arguments to get_schema_mode via a request object, either of type GetSchemaModeRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaModeRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_schema_mode(name: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode

Pass arguments to get_schema_mode via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  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

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 2523

def get_schema_mode request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaModeRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_schema_mode.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_schema_mode.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_schema_mode.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :get_schema_mode, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_schema_registry(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry` #get_schema_registry(name: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry`

Get the schema registry instance.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaRegistryRequest.new

# Call the get_schema_registry method.
result = client.get_schema_registry request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry.
p result

Overloads:

#get_schema_registry(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry

Pass arguments to get_schema_registry via a request object, either of type GetSchemaRegistryRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaRegistryRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_schema_registry(name: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry

Pass arguments to get_schema_registry via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The name of the schema registry instance to return. Structured like: projects/{project}/locations/{location}/schemaRegistries/{schema_registry}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 297

def get_schema_registry request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetSchemaRegistryRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_schema_registry.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_schema_registry.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_schema_registry.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :get_schema_registry, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_version(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion` #get_version(name: nil, deleted: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetVersionRequest.new

# Call the get_version method.
result = client.get_version request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion.
p result

Overloads:

#get_version(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion

Pass arguments to get_version via a request object, either of type GetVersionRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetVersionRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_version(name: nil, deleted: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion

Pass arguments to get_version via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  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}
- deleted (::Boolean) (defaults to: nil) —
  Optional. If true, no matter if the subject/version is soft-deleted or not, it returns the version details. If false, it returns NOT_FOUND error if the subject/version is soft-deleted. The default is false.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 1583

def get_version request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::GetVersionRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_version.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_version.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_version.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :get_version, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_contexts(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_contexts(parent: nil) ⇒ `::Google::Api::HttpBody`

List contexts for a schema registry.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListContextsRequest.new

# Call the list_contexts method.
result = client.list_contexts request

# The returned object is of type Google::Api::HttpBody.
p result

Overloads:

#list_contexts(request, options = nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_contexts via a request object, either of type ListContextsRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListContextsRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_contexts(parent: nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_contexts via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The parent of the contexts. Structured like: projects/{project}/locations/{location}/schemaRegistries/{schema_registry}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Api::HttpBody)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Api::HttpBody)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 736

def list_contexts request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListContextsRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_contexts.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_contexts.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_contexts.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :list_contexts, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_referenced_schemas(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_referenced_schemas(parent: nil) ⇒ `::Google::Api::HttpBody`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListReferencedSchemasRequest.new

# Call the list_referenced_schemas method.
result = client.list_referenced_schemas request

# The returned object is of type Google::Api::HttpBody.
p result

Overloads:

#list_referenced_schemas(request, options = nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_referenced_schemas via a request object, either of type ListReferencedSchemasRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListReferencedSchemasRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_referenced_schemas(parent: nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_referenced_schemas via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- parent (::String) (defaults to: nil) —
  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}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Api::HttpBody)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Api::HttpBody)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 2059

def list_referenced_schemas request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListReferencedSchemasRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_referenced_schemas.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_referenced_schemas.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_referenced_schemas.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :list_referenced_schemas, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_schema_registries(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse` #list_schema_registries(parent: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse`

List schema registries.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesRequest.new

# Call the list_schema_registries method.
result = client.list_schema_registries request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse.
p result

Overloads:

#list_schema_registries(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse

Pass arguments to list_schema_registries via a request object, either of type ListSchemaRegistriesRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_schema_registries(parent: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse

Pass arguments to list_schema_registries via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The parent whose schema registry instances are to be listed. Structured like: projects/{project}/locations/{location}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 383

def list_schema_registries request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_schema_registries.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_schema_registries.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_schema_registries.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :list_schema_registries, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_schema_types(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_schema_types(parent: nil) ⇒ `::Google::Api::HttpBody`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaTypesRequest.new

# Call the list_schema_types method.
result = client.list_schema_types request

# The returned object is of type Google::Api::HttpBody.
p result

Overloads:

#list_schema_types(request, options = nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_schema_types via a request object, either of type ListSchemaTypesRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaTypesRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_schema_types(parent: nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_schema_types via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The parent schema registry whose schema types are to be listed. Structured like: projects/{project}/locations/{location}/schemaRegistries/{schema_registry}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Api::HttpBody)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Api::HttpBody)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 1101

def list_schema_types request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaTypesRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_schema_types.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_schema_types.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_schema_types.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :list_schema_types, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_schema_versions(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_schema_versions(parent: nil, subject: nil, deleted: nil) ⇒ `::Google::Api::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}].

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaVersionsRequest.new

# Call the list_schema_versions method.
result = client.list_schema_versions request

# The returned object is of type Google::Api::HttpBody.
p result

Overloads:

#list_schema_versions(request, options = nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_schema_versions via a request object, either of type ListSchemaVersionsRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaVersionsRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_schema_versions(parent: nil, subject: nil, deleted: nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_schema_versions via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- parent (::String) (defaults to: nil) —
  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}
- subject (::String) (defaults to: nil) —
  Optional. The subject to filter the subjects by.
- deleted (::Boolean) (defaults to: nil) —
  Optional. If true, the response will include soft-deleted versions of the schema, even if the subject is soft-deleted. The default is false.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Api::HttpBody)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Api::HttpBody)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 1013

def list_schema_versions request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaVersionsRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_schema_versions.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_schema_versions.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_schema_versions.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :list_schema_versions, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_subjects(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_subjects(parent: nil, subject_prefix: nil, deleted: nil) ⇒ `::Google::Api::HttpBody`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSubjectsRequest.new

# Call the list_subjects method.
result = client.list_subjects request

# The returned object is of type Google::Api::HttpBody.
p result

Overloads:

#list_subjects(request, options = nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_subjects via a request object, either of type ListSubjectsRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSubjectsRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_subjects(parent: nil, subject_prefix: nil, deleted: nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_subjects via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- parent (::String) (defaults to: nil) —
  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}
- subject_prefix (::String) (defaults to: nil) —
  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.
- deleted (::Boolean) (defaults to: nil) —
  Optional. If true, the response will include soft-deleted subjects. The default is false.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Api::HttpBody)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Api::HttpBody)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 1200

def list_subjects request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSubjectsRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_subjects.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_subjects.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_subjects.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :list_subjects, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_subjects_by_schema_id(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_subjects_by_schema_id(parent: nil, subject: nil, deleted: nil) ⇒ `::Google::Api::HttpBody`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSubjectsBySchemaIdRequest.new

# Call the list_subjects_by_schema_id method.
result = client.list_subjects_by_schema_id request

# The returned object is of type Google::Api::HttpBody.
p result

Overloads:

#list_subjects_by_schema_id(request, options = nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_subjects_by_schema_id via a request object, either of type ListSubjectsBySchemaIdRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSubjectsBySchemaIdRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_subjects_by_schema_id(parent: nil, subject: nil, deleted: nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_subjects_by_schema_id via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- parent (::String) (defaults to: nil) —
  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}
- subject (::String) (defaults to: nil) —
  Optional. The subject to filter the subjects by.
- deleted (::Boolean) (defaults to: nil) —
  Optional. If true, the response will include soft-deleted subjects. The default is false.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Api::HttpBody)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Api::HttpBody)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 1295

def list_subjects_by_schema_id request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSubjectsBySchemaIdRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_subjects_by_schema_id.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_subjects_by_schema_id.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_subjects_by_schema_id.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :list_subjects_by_schema_id, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_versions(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_versions(parent: nil, deleted: nil) ⇒ `::Google::Api::HttpBody`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListVersionsRequest.new

# Call the list_versions method.
result = client.list_versions request

# The returned object is of type Google::Api::HttpBody.
p result

Overloads:

#list_versions(request, options = nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_versions via a request object, either of type ListVersionsRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListVersionsRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_versions(parent: nil, deleted: nil) ⇒ ::Google::Api::HttpBody

Pass arguments to list_versions via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- parent (::String) (defaults to: nil) —
  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}
- deleted (::Boolean) (defaults to: nil) —
  Optional. If true, the response will include soft-deleted versions of an active or soft-deleted subject. The default is false.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Api::HttpBody)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Api::HttpBody)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 1768

def list_versions request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListVersionsRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_versions.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_versions.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_versions.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :list_versions, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#logger ⇒ `Logger`

The logger used for request/response debug logging.

Returns:

(Logger)



245
246
247

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 245

def logger
  @managed_schema_registry_stub.logger
end

#lookup_version(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion` #lookup_version(parent: nil, schema_type: nil, schema: nil, references: nil, normalize: nil, deleted: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion`

Lookup a schema under the specified subject.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::LookupVersionRequest.new

# Call the lookup_version method.
result = client.lookup_version request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion.
p result

Overloads:

#lookup_version(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion

Pass arguments to lookup_version via a request object, either of type LookupVersionRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::LookupVersionRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#lookup_version(parent: nil, schema_type: nil, schema: nil, references: nil, normalize: nil, deleted: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion

Pass arguments to lookup_version via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- parent (::String) (defaults to: nil) —
  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}
- schema_type (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema::SchemaType) (defaults to: nil) —
  Optional. The schema type of the schema.
- schema (::String) (defaults to: nil) —
  Required. The schema payload
- references (::Array<::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema::SchemaReference, ::Hash>) (defaults to: nil) —
  Optional. The schema references used by the schema.
- normalize (::Boolean) (defaults to: nil) —
  Optional. If true, the schema will be normalized before being looked up. The default is false.
- deleted (::Boolean) (defaults to: nil) —
  Optional. If true, soft-deleted versions will be included in lookup, no matter if the subject is active or soft-deleted. If false, soft-deleted versions will be excluded. The default is false.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 1491

def lookup_version request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::LookupVersionRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.lookup_version.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.lookup_version.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.lookup_version.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :lookup_version, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#universe_domain ⇒ `String`

The effective universe domain

Returns:

(String)



154
155
156

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 154

def universe_domain
  @managed_schema_registry_stub.universe_domain
end

#update_schema_config(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig` #update_schema_config(name: nil, compatibility: nil, normalize: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig`

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

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::UpdateSchemaConfigRequest.new

# Call the update_schema_config method.
result = client.update_schema_config request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig.
p result

Overloads:

#update_schema_config(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig

Pass arguments to update_schema_config via a request object, either of type UpdateSchemaConfigRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::UpdateSchemaConfigRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_schema_config(name: nil, compatibility: nil, normalize: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig

Pass arguments to update_schema_config via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  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.
- compatibility (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig::CompatibilityType) (defaults to: nil) —
  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.
- normalize (::Boolean) (defaults to: nil) —
  Optional. If true, the schema will be normalized before being stored or looked up. The default is false. Cannot be unset for a SchemaRegistry-level SchemaConfig. If unset on a SchemaSubject-level SchemaConfig, removes the normalize field for the SchemaConfig.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 2349

def update_schema_config request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::UpdateSchemaConfigRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.update_schema_config.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.update_schema_config.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_schema_config.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :update_schema_config, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#update_schema_mode(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode` #update_schema_mode(name: nil, mode: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode`

Update mode at global level or for a subject.

Examples:

Basic example

require "google/cloud/managed_kafka/schema_registry/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::ManagedKafka::SchemaRegistry::V1::UpdateSchemaModeRequest.new

# Call the update_schema_mode method.
result = client.update_schema_mode request

# The returned object is of type Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode.
p result

Overloads:

#update_schema_mode(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode

Pass arguments to update_schema_mode via a request object, either of type UpdateSchemaModeRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::UpdateSchemaModeRequest, ::Hash) —
  A request object representing the call parameters. Required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_schema_mode(name: nil, mode: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode

Pass arguments to update_schema_mode via keyword arguments. Note that at least one keyword argument is required. To specify no parameters, or to keep all the default parameter values, pass an empty Hash as a request object (see above).
Parameters:
- name (::String) (defaults to: nil) —
  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
- mode (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode::ModeType) (defaults to: nil) —
  Required. The mode type.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/managed_kafka/schema_registry/v1/managed_schema_registry/client.rb', line 2612

def update_schema_mode request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::UpdateSchemaModeRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.update_schema_mode.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.update_schema_mode.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_schema_mode.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_schema_registry_stub.call_rpc :update_schema_mode, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

Class: Google::Cloud::ManagedKafka::SchemaRegistry::V1::ManagedSchemaRegistry::Client

Overview

Defined Under Namespace

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Paths

Constructor Details

#initialize {|config| ... } ⇒ Client

Examples:

Instance Attribute Details

#location_client ⇒ Google::Cloud::Location::Locations::Client (readonly)

Class Method Details

.configure {|config| ... } ⇒ Client::Configuration

Examples:

Instance Method Details

Examples:

Basic example

#configure {|config| ... } ⇒ Client::Configuration

#create_schema_registry(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry #create_schema_registry(parent: nil, schema_registry_id: nil, schema_registry: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry

Examples:

Basic example

Examples:

Basic example

#delete_schema_config(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig #delete_schema_config(name: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig

Examples:

Basic example

#delete_schema_mode(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode #delete_schema_mode(name: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode

Examples:

Basic example

#delete_schema_registry(request, options = nil) ⇒ ::Google::Protobuf::Empty #delete_schema_registry(name: nil) ⇒ ::Google::Protobuf::Empty

Examples:

Basic example

#delete_subject(request, options = nil) ⇒ ::Google::Api::HttpBody #delete_subject(name: nil, permanent: nil) ⇒ ::Google::Api::HttpBody

Examples:

Basic example

#delete_version(request, options = nil) ⇒ ::Google::Api::HttpBody #delete_version(name: nil, permanent: nil) ⇒ ::Google::Api::HttpBody

Examples:

Basic example

#get_context(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context #get_context(name: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context

Examples:

Basic example

#get_raw_schema(request, options = nil) ⇒ ::Google::Api::HttpBody #get_raw_schema(name: nil, subject: nil) ⇒ ::Google::Api::HttpBody

Examples:

Basic example

#get_raw_schema_version(request, options = nil) ⇒ ::Google::Api::HttpBody #get_raw_schema_version(name: nil, deleted: nil) ⇒ ::Google::Api::HttpBody

Examples:

Basic example

#get_schema(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema #get_schema(name: nil, subject: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema

Examples:

Basic example

#get_schema_config(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig #get_schema_config(name: nil, default_to_global: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig

Examples:

Basic example

#get_schema_mode(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode #get_schema_mode(name: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode

Examples:

Basic example

#get_schema_registry(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry #get_schema_registry(name: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry

Examples:

Basic example

#get_version(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion #get_version(name: nil, deleted: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion

Examples:

Basic example

#list_contexts(request, options = nil) ⇒ ::Google::Api::HttpBody #list_contexts(parent: nil) ⇒ ::Google::Api::HttpBody

Examples:

Basic example

#list_referenced_schemas(request, options = nil) ⇒ ::Google::Api::HttpBody #list_referenced_schemas(parent: nil) ⇒ ::Google::Api::HttpBody

Examples:

Basic example

#list_schema_registries(request, options = nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse #list_schema_registries(parent: nil) ⇒ ::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse

Examples:

Basic example

#list_schema_types(request, options = nil) ⇒ ::Google::Api::HttpBody #list_schema_types(parent: nil) ⇒ ::Google::Api::HttpBody

Examples:

Basic example

#list_schema_versions(request, options = nil) ⇒ ::Google::Api::HttpBody #list_schema_versions(parent: nil, subject: nil, deleted: nil) ⇒ ::Google::Api::HttpBody

Examples:

Basic example

#list_subjects(request, options = nil) ⇒ ::Google::Api::HttpBody #list_subjects(parent: nil, subject_prefix: nil, deleted: nil) ⇒ ::Google::Api::HttpBody

Examples:

#initialize {|config| ... } ⇒ `Client`

#location_client ⇒ `Google::Cloud::Location::Locations::Client` (readonly)

.configure {|config| ... } ⇒ `Client::Configuration`

#configure {|config| ... } ⇒ `Client::Configuration`

#create_schema_registry(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry` #create_schema_registry(parent: nil, schema_registry_id: nil, schema_registry: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry`

#delete_schema_config(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig` #delete_schema_config(name: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig`

#delete_schema_mode(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode` #delete_schema_mode(name: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode`

#delete_schema_registry(request, options = nil) ⇒ `::Google::Protobuf::Empty` #delete_schema_registry(name: nil) ⇒ `::Google::Protobuf::Empty`

#delete_subject(request, options = nil) ⇒ `::Google::Api::HttpBody` #delete_subject(name: nil, permanent: nil) ⇒ `::Google::Api::HttpBody`

#delete_version(request, options = nil) ⇒ `::Google::Api::HttpBody` #delete_version(name: nil, permanent: nil) ⇒ `::Google::Api::HttpBody`

#get_context(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context` #get_context(name: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Context`

#get_raw_schema(request, options = nil) ⇒ `::Google::Api::HttpBody` #get_raw_schema(name: nil, subject: nil) ⇒ `::Google::Api::HttpBody`

#get_raw_schema_version(request, options = nil) ⇒ `::Google::Api::HttpBody` #get_raw_schema_version(name: nil, deleted: nil) ⇒ `::Google::Api::HttpBody`

#get_schema(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema` #get_schema(name: nil, subject: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::Schema`

#get_schema_config(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig` #get_schema_config(name: nil, default_to_global: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig`

#get_schema_mode(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode` #get_schema_mode(name: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode`

#get_schema_registry(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry` #get_schema_registry(name: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaRegistry`

#get_version(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion` #get_version(name: nil, deleted: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion`

#list_contexts(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_contexts(parent: nil) ⇒ `::Google::Api::HttpBody`

#list_referenced_schemas(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_referenced_schemas(parent: nil) ⇒ `::Google::Api::HttpBody`

#list_schema_registries(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse` #list_schema_registries(parent: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::ListSchemaRegistriesResponse`

#list_schema_types(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_schema_types(parent: nil) ⇒ `::Google::Api::HttpBody`

#list_schema_versions(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_schema_versions(parent: nil, subject: nil, deleted: nil) ⇒ `::Google::Api::HttpBody`

#list_subjects(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_subjects(parent: nil, subject_prefix: nil, deleted: nil) ⇒ `::Google::Api::HttpBody`

#list_subjects_by_schema_id(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_subjects_by_schema_id(parent: nil, subject: nil, deleted: nil) ⇒ `::Google::Api::HttpBody`

#list_versions(request, options = nil) ⇒ `::Google::Api::HttpBody` #list_versions(parent: nil, deleted: nil) ⇒ `::Google::Api::HttpBody`

#logger ⇒ `Logger`

#lookup_version(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion` #lookup_version(parent: nil, schema_type: nil, schema: nil, references: nil, normalize: nil, deleted: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaVersion`

#universe_domain ⇒ `String`

#update_schema_config(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig` #update_schema_config(name: nil, compatibility: nil, normalize: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaConfig`

#update_schema_mode(request, options = nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode` #update_schema_mode(name: nil, mode: nil) ⇒ `::Google::Cloud::ManagedKafka::SchemaRegistry::V1::SchemaMode`