Module: Google::Cloud::Dialogflow::CX

Defined in:
lib/google/cloud/dialogflow/cx.rb,
lib/google/cloud/dialogflow/cx/version.rb

Constant Summary collapse

VERSION = 
"1.5.0"

Class Method Summary collapse

Class Method Details

.agents(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Agents.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Agents::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Agents service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Agents service. You can determine whether the method will succeed by calling agents_available?.

About Agents

Service for managing Agents.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 216

def self.agents version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Agents)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.agents_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Agents service is supported by the current client. If true, you can retrieve a client object by calling agents. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Agents service, or if the versioned client gem needs an update to support the Agents service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 240

def self.agents_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Agents
  service_module = service_module.const_get :Agents
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.changelogs(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Changelogs.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Changelogs::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Changelogs service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Changelogs service. You can determine whether the method will succeed by calling changelogs_available?.

About Changelogs

Service for managing Changelogs.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



286
287
288
289
290
291
292
293
294
295
296
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 286

def self.changelogs version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Changelogs)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.changelogs_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Changelogs service is supported by the current client. If true, you can retrieve a client object by calling changelogs. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Changelogs service, or if the versioned client gem needs an update to support the Changelogs service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 310

def self.changelogs_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Changelogs
  service_module = service_module.const_get :Changelogs
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.configure {|::Google::Cloud.configure.dialogflow_cx| ... } ⇒ ::Google::Cloud::Config

Configure the google-cloud-dialogflow-cx library.

The following configuration parameters are supported:

  • credentials (type: String, Hash, Google::Auth::Credentials) - The path to the keyfile as a String, the contents of the keyfile as a Hash, or a Google::Auth::Credentials object.
  • lib_name (type: String) - The library name as recorded in instrumentation and logging.
  • lib_version (type: String) - The library version as recorded in instrumentation and logging.
  • interceptors (type: Array<GRPC::ClientInterceptor>) - An array of interceptors that are run before calls are executed.
  • timeout (type: Numeric) - Default timeout in seconds.
  • metadata (type: Hash{Symbol=>String}) - Additional headers to be sent with the call.
  • retry_policy (type: Hash) - The retry policy. The value is a hash with the following keys:
    • :initial_delay (type: Numeric) - The initial delay in seconds.
    • :max_delay (type: Numeric) - The max delay in seconds.
    • :multiplier (type: Numeric) - The incremental backoff multiplier.
    • :jitter (type: Numeric) - The jitter in seconds. Default: 1.0.
    • :retry_codes (type: Array<String>) - The error codes that should trigger a retry.

Yields:

Returns:

  • (::Google::Cloud::Config) —

    The default configuration used by this library



1485
1486
1487
1488
1489
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1485

def self.configure
  yield ::Google::Cloud.configure.dialogflow_cx if block_given?

  ::Google::Cloud.configure.dialogflow_cx
end

.deployments(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Deployments.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Deployments::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Deployments service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Deployments service. You can determine whether the method will succeed by calling deployments_available?.

About Deployments

Service for managing Deployments.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



356
357
358
359
360
361
362
363
364
365
366
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 356

def self.deployments version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Deployments)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.deployments_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Deployments service is supported by the current client. If true, you can retrieve a client object by calling deployments. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Deployments service, or if the versioned client gem needs an update to support the Deployments service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 380

def self.deployments_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Deployments
  service_module = service_module.const_get :Deployments
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.entity_types(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for EntityTypes.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::EntityTypes::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the EntityTypes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the EntityTypes service. You can determine whether the method will succeed by calling entity_types_available?.

About EntityTypes

Service for managing EntityTypes.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



426
427
428
429
430
431
432
433
434
435
436
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 426

def self.entity_types version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:EntityTypes)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.entity_types_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the EntityTypes service is supported by the current client. If true, you can retrieve a client object by calling entity_types. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the EntityTypes service, or if the versioned client gem needs an update to support the EntityTypes service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 450

def self.entity_types_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :EntityTypes
  service_module = service_module.const_get :EntityTypes
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.environments(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Environments.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Environments::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Environments service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Environments service. You can determine whether the method will succeed by calling environments_available?.

About Environments

Service for managing Environments.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



923
924
925
926
927
928
929
930
931
932
933
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 923

def self.environments version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Environments)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.environments_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Environments service is supported by the current client. If true, you can retrieve a client object by calling environments. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Environments service, or if the versioned client gem needs an update to support the Environments service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 947

def self.environments_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Environments
  service_module = service_module.const_get :Environments
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.examples(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Examples.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Examples::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Examples service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Examples service. You can determine whether the method will succeed by calling examples_available?.

About Examples

Service for managing Examples.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



993
994
995
996
997
998
999
1000
1001
1002
1003
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 993

def self.examples version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Examples)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.examples_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Examples service is supported by the current client. If true, you can retrieve a client object by calling examples. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Examples service, or if the versioned client gem needs an update to support the Examples service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1017

def self.examples_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Examples
  service_module = service_module.const_get :Examples
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.experiments(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Experiments.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Experiments::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Experiments service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Experiments service. You can determine whether the method will succeed by calling experiments_available?.

About Experiments

Service for managing Experiments.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1063

def self.experiments version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Experiments)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.experiments_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Experiments service is supported by the current client. If true, you can retrieve a client object by calling experiments. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Experiments service, or if the versioned client gem needs an update to support the Experiments service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1087

def self.experiments_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Experiments
  service_module = service_module.const_get :Experiments
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.flows(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Flows.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Flows::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Flows service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Flows service. You can determine whether the method will succeed by calling flows_available?.

About Flows

Service for managing Flows.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 146

def self.flows version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Flows)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.flows_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Flows service is supported by the current client. If true, you can retrieve a client object by calling flows. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Flows service, or if the versioned client gem needs an update to support the Flows service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 170

def self.flows_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Flows
  service_module = service_module.const_get :Flows
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.generators(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Generators.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Generators::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Generators service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Generators service. You can determine whether the method will succeed by calling generators_available?.

About Generators

Service for managing Generators

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1133

def self.generators version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Generators)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.generators_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Generators service is supported by the current client. If true, you can retrieve a client object by calling generators. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Generators service, or if the versioned client gem needs an update to support the Generators service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1157

def self.generators_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Generators
  service_module = service_module.const_get :Generators
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.intents(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Intents.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Intents::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Intents service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Intents service. You can determine whether the method will succeed by calling intents_available?.

About Intents

Service for managing Intents.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



496
497
498
499
500
501
502
503
504
505
506
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 496

def self.intents version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Intents)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.intents_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Intents service is supported by the current client. If true, you can retrieve a client object by calling intents. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Intents service, or if the versioned client gem needs an update to support the Intents service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 520

def self.intents_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Intents
  service_module = service_module.const_get :Intents
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.pages(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Pages.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Pages::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Pages service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Pages service. You can determine whether the method will succeed by calling pages_available?.

About Pages

Service for managing Pages.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 76

def self.pages version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Pages)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.pages_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Pages service is supported by the current client. If true, you can retrieve a client object by calling pages. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Pages service, or if the versioned client gem needs an update to support the Pages service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 100

def self.pages_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Pages
  service_module = service_module.const_get :Pages
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.playbooks(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Playbooks.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Playbooks::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Playbooks service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Playbooks service. You can determine whether the method will succeed by calling playbooks_available?.

About Playbooks

Service for managing Playbooks.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1203

def self.playbooks version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Playbooks)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.playbooks_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Playbooks service is supported by the current client. If true, you can retrieve a client object by calling playbooks. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Playbooks service, or if the versioned client gem needs an update to support the Playbooks service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1227

def self.playbooks_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Playbooks
  service_module = service_module.const_get :Playbooks
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.security_settings_service(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for SecuritySettingsService.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::SecuritySettingsService::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the SecuritySettingsService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the SecuritySettingsService service. You can determine whether the method will succeed by calling security_settings_service_available?.

About SecuritySettingsService

Service for managing security settings for Dialogflow.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1273

def self.security_settings_service version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:SecuritySettingsService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.security_settings_service_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the SecuritySettingsService service is supported by the current client. If true, you can retrieve a client object by calling security_settings_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the SecuritySettingsService service, or if the versioned client gem needs an update to support the SecuritySettingsService service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1297

def self.security_settings_service_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :SecuritySettingsService
  service_module = service_module.const_get :SecuritySettingsService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.session_entity_types(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for SessionEntityTypes.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::SessionEntityTypes::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the SessionEntityTypes service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the SessionEntityTypes service. You can determine whether the method will succeed by calling session_entity_types_available?.

About SessionEntityTypes

Service for managing SessionEntityTypes.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



567
568
569
570
571
572
573
574
575
576
577
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 567

def self.session_entity_types version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:SessionEntityTypes)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.session_entity_types_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the SessionEntityTypes service is supported by the current client. If true, you can retrieve a client object by calling session_entity_types. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the SessionEntityTypes service, or if the versioned client gem needs an update to support the SessionEntityTypes service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 591

def self.session_entity_types_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :SessionEntityTypes
  service_module = service_module.const_get :SessionEntityTypes
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.sessions(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Sessions.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Sessions::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Sessions service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Sessions service. You can determine whether the method will succeed by calling sessions_available?.

About Sessions

A session represents an interaction with a user. You retrieve user input and pass it to the DetectIntent method to determine user intent and respond.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



640
641
642
643
644
645
646
647
648
649
650
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 640

def self.sessions version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Sessions)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.sessions_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Sessions service is supported by the current client. If true, you can retrieve a client object by calling sessions. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Sessions service, or if the versioned client gem needs an update to support the Sessions service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 664

def self.sessions_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Sessions
  service_module = service_module.const_get :Sessions
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.test_cases(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for TestCases.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::TestCases::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the TestCases service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the TestCases service. You can determine whether the method will succeed by calling test_cases_available?.

About TestCases

Service for managing Test Cases and Test Case Results.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



782
783
784
785
786
787
788
789
790
791
792
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 782

def self.test_cases version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:TestCases)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.test_cases_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the TestCases service is supported by the current client. If true, you can retrieve a client object by calling test_cases. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the TestCases service, or if the versioned client gem needs an update to support the TestCases service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 806

def self.test_cases_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :TestCases
  service_module = service_module.const_get :TestCases
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.tools(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Tools.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Tools::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Tools service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Tools service. You can determine whether the method will succeed by calling tools_available?.

About Tools

Service for managing Tools.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1343

def self.tools version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Tools)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.tools_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Tools service is supported by the current client. If true, you can retrieve a client object by calling tools. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Tools service, or if the versioned client gem needs an update to support the Tools service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1367

def self.tools_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Tools
  service_module = service_module.const_get :Tools
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.transition_route_groups(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for TransitionRouteGroups.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::TransitionRouteGroups::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the TransitionRouteGroups service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the TransitionRouteGroups service. You can determine whether the method will succeed by calling transition_route_groups_available?.

About TransitionRouteGroups

Service for managing TransitionRouteGroups.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



711
712
713
714
715
716
717
718
719
720
721
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 711

def self.transition_route_groups version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:TransitionRouteGroups)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.transition_route_groups_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the TransitionRouteGroups service is supported by the current client. If true, you can retrieve a client object by calling transition_route_groups. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the TransitionRouteGroups service, or if the versioned client gem needs an update to support the TransitionRouteGroups service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 735

def self.transition_route_groups_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :TransitionRouteGroups
  service_module = service_module.const_get :TransitionRouteGroups
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.versions(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Versions.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Versions::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Versions service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Versions service. You can determine whether the method will succeed by calling versions_available?.

About Versions

Service for managing Versions.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1413

def self.versions version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Versions)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.versions_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Versions service is supported by the current client. If true, you can retrieve a client object by calling versions. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Versions service, or if the versioned client gem needs an update to support the Versions service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 1437

def self.versions_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Versions
  service_module = service_module.const_get :Versions
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.webhooks(version: :v3, transport: :grpc, &block) ⇒ ::Object

Create a new client object for Webhooks.

By default, this returns an instance of Google::Cloud::Dialogflow::CX::V3::Webhooks::Client for a gRPC client for version V3 of the API. However, you can specify a different API version by passing it in the version parameter. If the Webhooks service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the Webhooks service. You can determine whether the method will succeed by calling webhooks_available?.

About Webhooks

Service for managing Webhooks.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (::Object) —

    A client object for the specified version.



852
853
854
855
856
857
858
859
860
861
862
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 852

def self.webhooks version: :v3, transport: :grpc, &block
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"

  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::Dialogflow::CX.const_get(package_name).const_get(:Webhooks)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.webhooks_available?(version: :v3, transport: :grpc) ⇒ boolean

Determines whether the Webhooks service is supported by the current client. If true, you can retrieve a client object by calling webhooks. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the Webhooks service, or if the versioned client gem needs an update to support the Webhooks service.

Parameters:

  • version (::String, ::Symbol) (defaults to: :v3) —

    The API version to connect to. Optional. Defaults to :v3.

  • transport (:grpc, :rest) (defaults to: :grpc) —

    The transport to use. Defaults to :grpc.

Returns:

  • (boolean) —

    Whether the service is available.



876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
 
# File 'lib/google/cloud/dialogflow/cx.rb', line 876

def self.webhooks_available? version: :v3, transport: :grpc
  require "google/cloud/dialogflow/cx/#{version.to_s.downcase}"
  package_name = Google::Cloud::Dialogflow::CX
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::Dialogflow::CX.const_get package_name
  return false unless service_module.const_defined? :Webhooks
  service_module = service_module.const_get :Webhooks
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end