google-cloud-document_ai-v1beta3 0.36.1 → 0.38.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/README.md +30 -20
- data/lib/google/cloud/document_ai/v1beta3/document_processor_service/client.rb +47 -27
- data/lib/google/cloud/document_ai/v1beta3/document_processor_service/operations.rb +12 -15
- data/lib/google/cloud/document_ai/v1beta3/document_processor_service/rest/client.rb +47 -27
- data/lib/google/cloud/document_ai/v1beta3/document_processor_service/rest/operations.rb +43 -38
- data/lib/google/cloud/document_ai/v1beta3/document_processor_service/rest/service_stub.rb +198 -140
- data/lib/google/cloud/document_ai/v1beta3/document_service/client.rb +32 -8
- data/lib/google/cloud/document_ai/v1beta3/document_service/operations.rb +12 -15
- data/lib/google/cloud/document_ai/v1beta3/document_service/rest/client.rb +32 -8
- data/lib/google/cloud/document_ai/v1beta3/document_service/rest/operations.rb +43 -38
- data/lib/google/cloud/document_ai/v1beta3/document_service/rest/service_stub.rb +70 -44
- data/lib/google/cloud/document_ai/v1beta3/version.rb +1 -1
- data/lib/google/cloud/documentai/v1beta3/dataset_pb.rb +1 -1
- data/lib/google/cloud/documentai/v1beta3/document_schema_pb.rb +1 -1
- data/proto_docs/google/api/client.rb +39 -0
- data/proto_docs/google/cloud/documentai/v1beta3/dataset.rb +6 -0
- data/proto_docs/google/cloud/documentai/v1beta3/document_schema.rb +8 -0
- data/proto_docs/google/longrunning/operations.rb +19 -14
- metadata +5 -5
| @@ -30,7 +30,8 @@ module Google | |
| 30 30 | 
             
                        # including transcoding, making the REST call, and deserialing the response.
         | 
| 31 31 | 
             
                        #
         | 
| 32 32 | 
             
                        class ServiceStub
         | 
| 33 | 
            -
                           | 
| 33 | 
            +
                          # @private
         | 
| 34 | 
            +
                          def initialize endpoint:, endpoint_template:, universe_domain:, credentials:, logger:
         | 
| 34 35 | 
             
                            # These require statements are intentionally placed here to initialize
         | 
| 35 36 | 
             
                            # the REST modules only when it's required.
         | 
| 36 37 | 
             
                            require "gapic/rest"
         | 
| @@ -40,7 +41,9 @@ module Google | |
| 40 41 | 
             
                                                                         universe_domain: universe_domain,
         | 
| 41 42 | 
             
                                                                         credentials: credentials,
         | 
| 42 43 | 
             
                                                                         numeric_enums: true,
         | 
| 43 | 
            -
                                                                          | 
| 44 | 
            +
                                                                         service_name: self.class,
         | 
| 45 | 
            +
                                                                         raise_faraday_errors: false,
         | 
| 46 | 
            +
                                                                         logger: logger
         | 
| 44 47 | 
             
                          end
         | 
| 45 48 |  | 
| 46 49 | 
             
                          ##
         | 
| @@ -61,6 +64,15 @@ module Google | |
| 61 64 | 
             
                            @client_stub.endpoint
         | 
| 62 65 | 
             
                          end
         | 
| 63 66 |  | 
| 67 | 
            +
                          ##
         | 
| 68 | 
            +
                          # The logger used for request/response debug logging.
         | 
| 69 | 
            +
                          #
         | 
| 70 | 
            +
                          # @return [Logger]
         | 
| 71 | 
            +
                          #
         | 
| 72 | 
            +
                          def logger stub: false
         | 
| 73 | 
            +
                            stub ? @client_stub.stub_logger : @client_stub.logger
         | 
| 74 | 
            +
                          end
         | 
| 75 | 
            +
             | 
| 64 76 | 
             
                          ##
         | 
| 65 77 | 
             
                          # Baseline implementation for the process_document REST call
         | 
| 66 78 | 
             
                          #
         | 
| @@ -87,16 +99,18 @@ module Google | |
| 87 99 |  | 
| 88 100 | 
             
                            response = @client_stub.make_http_request(
         | 
| 89 101 | 
             
                              verb,
         | 
| 90 | 
            -
                              uri: | 
| 91 | 
            -
                              body: | 
| 92 | 
            -
                              params: | 
| 102 | 
            +
                              uri: uri,
         | 
| 103 | 
            +
                              body: body || "",
         | 
| 104 | 
            +
                              params: query_string_params,
         | 
| 105 | 
            +
                              method_name: "process_document",
         | 
| 93 106 | 
             
                              options: options
         | 
| 94 107 | 
             
                            )
         | 
| 95 108 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 96 109 | 
             
                            result = ::Google::Cloud::DocumentAI::V1beta3::ProcessResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 97 | 
            -
             | 
| 98 | 
            -
             | 
| 99 | 
            -
             | 
| 110 | 
            +
                            catch :response do
         | 
| 111 | 
            +
                              yield result, operation if block_given?
         | 
| 112 | 
            +
                              result
         | 
| 113 | 
            +
                            end
         | 
| 100 114 | 
             
                          end
         | 
| 101 115 |  | 
| 102 116 | 
             
                          ##
         | 
| @@ -125,16 +139,18 @@ module Google | |
| 125 139 |  | 
| 126 140 | 
             
                            response = @client_stub.make_http_request(
         | 
| 127 141 | 
             
                              verb,
         | 
| 128 | 
            -
                              uri: | 
| 129 | 
            -
                              body: | 
| 130 | 
            -
                              params: | 
| 142 | 
            +
                              uri: uri,
         | 
| 143 | 
            +
                              body: body || "",
         | 
| 144 | 
            +
                              params: query_string_params,
         | 
| 145 | 
            +
                              method_name: "batch_process_documents",
         | 
| 131 146 | 
             
                              options: options
         | 
| 132 147 | 
             
                            )
         | 
| 133 148 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 134 149 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 135 | 
            -
             | 
| 136 | 
            -
             | 
| 137 | 
            -
             | 
| 150 | 
            +
                            catch :response do
         | 
| 151 | 
            +
                              yield result, operation if block_given?
         | 
| 152 | 
            +
                              result
         | 
| 153 | 
            +
                            end
         | 
| 138 154 | 
             
                          end
         | 
| 139 155 |  | 
| 140 156 | 
             
                          ##
         | 
| @@ -163,16 +179,18 @@ module Google | |
| 163 179 |  | 
| 164 180 | 
             
                            response = @client_stub.make_http_request(
         | 
| 165 181 | 
             
                              verb,
         | 
| 166 | 
            -
                              uri: | 
| 167 | 
            -
                              body: | 
| 168 | 
            -
                              params: | 
| 182 | 
            +
                              uri: uri,
         | 
| 183 | 
            +
                              body: body || "",
         | 
| 184 | 
            +
                              params: query_string_params,
         | 
| 185 | 
            +
                              method_name: "fetch_processor_types",
         | 
| 169 186 | 
             
                              options: options
         | 
| 170 187 | 
             
                            )
         | 
| 171 188 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 172 189 | 
             
                            result = ::Google::Cloud::DocumentAI::V1beta3::FetchProcessorTypesResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 173 | 
            -
             | 
| 174 | 
            -
             | 
| 175 | 
            -
             | 
| 190 | 
            +
                            catch :response do
         | 
| 191 | 
            +
                              yield result, operation if block_given?
         | 
| 192 | 
            +
                              result
         | 
| 193 | 
            +
                            end
         | 
| 176 194 | 
             
                          end
         | 
| 177 195 |  | 
| 178 196 | 
             
                          ##
         | 
| @@ -201,16 +219,18 @@ module Google | |
| 201 219 |  | 
| 202 220 | 
             
                            response = @client_stub.make_http_request(
         | 
| 203 221 | 
             
                              verb,
         | 
| 204 | 
            -
                              uri: | 
| 205 | 
            -
                              body: | 
| 206 | 
            -
                              params: | 
| 222 | 
            +
                              uri: uri,
         | 
| 223 | 
            +
                              body: body || "",
         | 
| 224 | 
            +
                              params: query_string_params,
         | 
| 225 | 
            +
                              method_name: "list_processor_types",
         | 
| 207 226 | 
             
                              options: options
         | 
| 208 227 | 
             
                            )
         | 
| 209 228 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 210 229 | 
             
                            result = ::Google::Cloud::DocumentAI::V1beta3::ListProcessorTypesResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 211 | 
            -
             | 
| 212 | 
            -
             | 
| 213 | 
            -
             | 
| 230 | 
            +
                            catch :response do
         | 
| 231 | 
            +
                              yield result, operation if block_given?
         | 
| 232 | 
            +
                              result
         | 
| 233 | 
            +
                            end
         | 
| 214 234 | 
             
                          end
         | 
| 215 235 |  | 
| 216 236 | 
             
                          ##
         | 
| @@ -239,16 +259,18 @@ module Google | |
| 239 259 |  | 
| 240 260 | 
             
                            response = @client_stub.make_http_request(
         | 
| 241 261 | 
             
                              verb,
         | 
| 242 | 
            -
                              uri: | 
| 243 | 
            -
                              body: | 
| 244 | 
            -
                              params: | 
| 262 | 
            +
                              uri: uri,
         | 
| 263 | 
            +
                              body: body || "",
         | 
| 264 | 
            +
                              params: query_string_params,
         | 
| 265 | 
            +
                              method_name: "get_processor_type",
         | 
| 245 266 | 
             
                              options: options
         | 
| 246 267 | 
             
                            )
         | 
| 247 268 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 248 269 | 
             
                            result = ::Google::Cloud::DocumentAI::V1beta3::ProcessorType.decode_json response.body, ignore_unknown_fields: true
         | 
| 249 | 
            -
             | 
| 250 | 
            -
             | 
| 251 | 
            -
             | 
| 270 | 
            +
                            catch :response do
         | 
| 271 | 
            +
                              yield result, operation if block_given?
         | 
| 272 | 
            +
                              result
         | 
| 273 | 
            +
                            end
         | 
| 252 274 | 
             
                          end
         | 
| 253 275 |  | 
| 254 276 | 
             
                          ##
         | 
| @@ -277,16 +299,18 @@ module Google | |
| 277 299 |  | 
| 278 300 | 
             
                            response = @client_stub.make_http_request(
         | 
| 279 301 | 
             
                              verb,
         | 
| 280 | 
            -
                              uri: | 
| 281 | 
            -
                              body: | 
| 282 | 
            -
                              params: | 
| 302 | 
            +
                              uri: uri,
         | 
| 303 | 
            +
                              body: body || "",
         | 
| 304 | 
            +
                              params: query_string_params,
         | 
| 305 | 
            +
                              method_name: "list_processors",
         | 
| 283 306 | 
             
                              options: options
         | 
| 284 307 | 
             
                            )
         | 
| 285 308 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 286 309 | 
             
                            result = ::Google::Cloud::DocumentAI::V1beta3::ListProcessorsResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 287 | 
            -
             | 
| 288 | 
            -
             | 
| 289 | 
            -
             | 
| 310 | 
            +
                            catch :response do
         | 
| 311 | 
            +
                              yield result, operation if block_given?
         | 
| 312 | 
            +
                              result
         | 
| 313 | 
            +
                            end
         | 
| 290 314 | 
             
                          end
         | 
| 291 315 |  | 
| 292 316 | 
             
                          ##
         | 
| @@ -315,16 +339,18 @@ module Google | |
| 315 339 |  | 
| 316 340 | 
             
                            response = @client_stub.make_http_request(
         | 
| 317 341 | 
             
                              verb,
         | 
| 318 | 
            -
                              uri: | 
| 319 | 
            -
                              body: | 
| 320 | 
            -
                              params: | 
| 342 | 
            +
                              uri: uri,
         | 
| 343 | 
            +
                              body: body || "",
         | 
| 344 | 
            +
                              params: query_string_params,
         | 
| 345 | 
            +
                              method_name: "get_processor",
         | 
| 321 346 | 
             
                              options: options
         | 
| 322 347 | 
             
                            )
         | 
| 323 348 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 324 349 | 
             
                            result = ::Google::Cloud::DocumentAI::V1beta3::Processor.decode_json response.body, ignore_unknown_fields: true
         | 
| 325 | 
            -
             | 
| 326 | 
            -
             | 
| 327 | 
            -
             | 
| 350 | 
            +
                            catch :response do
         | 
| 351 | 
            +
                              yield result, operation if block_given?
         | 
| 352 | 
            +
                              result
         | 
| 353 | 
            +
                            end
         | 
| 328 354 | 
             
                          end
         | 
| 329 355 |  | 
| 330 356 | 
             
                          ##
         | 
| @@ -353,16 +379,18 @@ module Google | |
| 353 379 |  | 
| 354 380 | 
             
                            response = @client_stub.make_http_request(
         | 
| 355 381 | 
             
                              verb,
         | 
| 356 | 
            -
                              uri: | 
| 357 | 
            -
                              body: | 
| 358 | 
            -
                              params: | 
| 382 | 
            +
                              uri: uri,
         | 
| 383 | 
            +
                              body: body || "",
         | 
| 384 | 
            +
                              params: query_string_params,
         | 
| 385 | 
            +
                              method_name: "train_processor_version",
         | 
| 359 386 | 
             
                              options: options
         | 
| 360 387 | 
             
                            )
         | 
| 361 388 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 362 389 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 363 | 
            -
             | 
| 364 | 
            -
             | 
| 365 | 
            -
             | 
| 390 | 
            +
                            catch :response do
         | 
| 391 | 
            +
                              yield result, operation if block_given?
         | 
| 392 | 
            +
                              result
         | 
| 393 | 
            +
                            end
         | 
| 366 394 | 
             
                          end
         | 
| 367 395 |  | 
| 368 396 | 
             
                          ##
         | 
| @@ -391,16 +419,18 @@ module Google | |
| 391 419 |  | 
| 392 420 | 
             
                            response = @client_stub.make_http_request(
         | 
| 393 421 | 
             
                              verb,
         | 
| 394 | 
            -
                              uri: | 
| 395 | 
            -
                              body: | 
| 396 | 
            -
                              params: | 
| 422 | 
            +
                              uri: uri,
         | 
| 423 | 
            +
                              body: body || "",
         | 
| 424 | 
            +
                              params: query_string_params,
         | 
| 425 | 
            +
                              method_name: "get_processor_version",
         | 
| 397 426 | 
             
                              options: options
         | 
| 398 427 | 
             
                            )
         | 
| 399 428 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 400 429 | 
             
                            result = ::Google::Cloud::DocumentAI::V1beta3::ProcessorVersion.decode_json response.body, ignore_unknown_fields: true
         | 
| 401 | 
            -
             | 
| 402 | 
            -
             | 
| 403 | 
            -
             | 
| 430 | 
            +
                            catch :response do
         | 
| 431 | 
            +
                              yield result, operation if block_given?
         | 
| 432 | 
            +
                              result
         | 
| 433 | 
            +
                            end
         | 
| 404 434 | 
             
                          end
         | 
| 405 435 |  | 
| 406 436 | 
             
                          ##
         | 
| @@ -429,16 +459,18 @@ module Google | |
| 429 459 |  | 
| 430 460 | 
             
                            response = @client_stub.make_http_request(
         | 
| 431 461 | 
             
                              verb,
         | 
| 432 | 
            -
                              uri: | 
| 433 | 
            -
                              body: | 
| 434 | 
            -
                              params: | 
| 462 | 
            +
                              uri: uri,
         | 
| 463 | 
            +
                              body: body || "",
         | 
| 464 | 
            +
                              params: query_string_params,
         | 
| 465 | 
            +
                              method_name: "list_processor_versions",
         | 
| 435 466 | 
             
                              options: options
         | 
| 436 467 | 
             
                            )
         | 
| 437 468 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 438 469 | 
             
                            result = ::Google::Cloud::DocumentAI::V1beta3::ListProcessorVersionsResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 439 | 
            -
             | 
| 440 | 
            -
             | 
| 441 | 
            -
             | 
| 470 | 
            +
                            catch :response do
         | 
| 471 | 
            +
                              yield result, operation if block_given?
         | 
| 472 | 
            +
                              result
         | 
| 473 | 
            +
                            end
         | 
| 442 474 | 
             
                          end
         | 
| 443 475 |  | 
| 444 476 | 
             
                          ##
         | 
| @@ -467,16 +499,18 @@ module Google | |
| 467 499 |  | 
| 468 500 | 
             
                            response = @client_stub.make_http_request(
         | 
| 469 501 | 
             
                              verb,
         | 
| 470 | 
            -
                              uri: | 
| 471 | 
            -
                              body: | 
| 472 | 
            -
                              params: | 
| 502 | 
            +
                              uri: uri,
         | 
| 503 | 
            +
                              body: body || "",
         | 
| 504 | 
            +
                              params: query_string_params,
         | 
| 505 | 
            +
                              method_name: "delete_processor_version",
         | 
| 473 506 | 
             
                              options: options
         | 
| 474 507 | 
             
                            )
         | 
| 475 508 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 476 509 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 477 | 
            -
             | 
| 478 | 
            -
             | 
| 479 | 
            -
             | 
| 510 | 
            +
                            catch :response do
         | 
| 511 | 
            +
                              yield result, operation if block_given?
         | 
| 512 | 
            +
                              result
         | 
| 513 | 
            +
                            end
         | 
| 480 514 | 
             
                          end
         | 
| 481 515 |  | 
| 482 516 | 
             
                          ##
         | 
| @@ -505,16 +539,18 @@ module Google | |
| 505 539 |  | 
| 506 540 | 
             
                            response = @client_stub.make_http_request(
         | 
| 507 541 | 
             
                              verb,
         | 
| 508 | 
            -
                              uri: | 
| 509 | 
            -
                              body: | 
| 510 | 
            -
                              params: | 
| 542 | 
            +
                              uri: uri,
         | 
| 543 | 
            +
                              body: body || "",
         | 
| 544 | 
            +
                              params: query_string_params,
         | 
| 545 | 
            +
                              method_name: "deploy_processor_version",
         | 
| 511 546 | 
             
                              options: options
         | 
| 512 547 | 
             
                            )
         | 
| 513 548 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 514 549 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 515 | 
            -
             | 
| 516 | 
            -
             | 
| 517 | 
            -
             | 
| 550 | 
            +
                            catch :response do
         | 
| 551 | 
            +
                              yield result, operation if block_given?
         | 
| 552 | 
            +
                              result
         | 
| 553 | 
            +
                            end
         | 
| 518 554 | 
             
                          end
         | 
| 519 555 |  | 
| 520 556 | 
             
                          ##
         | 
| @@ -543,16 +579,18 @@ module Google | |
| 543 579 |  | 
| 544 580 | 
             
                            response = @client_stub.make_http_request(
         | 
| 545 581 | 
             
                              verb,
         | 
| 546 | 
            -
                              uri: | 
| 547 | 
            -
                              body: | 
| 548 | 
            -
                              params: | 
| 582 | 
            +
                              uri: uri,
         | 
| 583 | 
            +
                              body: body || "",
         | 
| 584 | 
            +
                              params: query_string_params,
         | 
| 585 | 
            +
                              method_name: "undeploy_processor_version",
         | 
| 549 586 | 
             
                              options: options
         | 
| 550 587 | 
             
                            )
         | 
| 551 588 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 552 589 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 553 | 
            -
             | 
| 554 | 
            -
             | 
| 555 | 
            -
             | 
| 590 | 
            +
                            catch :response do
         | 
| 591 | 
            +
                              yield result, operation if block_given?
         | 
| 592 | 
            +
                              result
         | 
| 593 | 
            +
                            end
         | 
| 556 594 | 
             
                          end
         | 
| 557 595 |  | 
| 558 596 | 
             
                          ##
         | 
| @@ -581,16 +619,18 @@ module Google | |
| 581 619 |  | 
| 582 620 | 
             
                            response = @client_stub.make_http_request(
         | 
| 583 621 | 
             
                              verb,
         | 
| 584 | 
            -
                              uri: | 
| 585 | 
            -
                              body: | 
| 586 | 
            -
                              params: | 
| 622 | 
            +
                              uri: uri,
         | 
| 623 | 
            +
                              body: body || "",
         | 
| 624 | 
            +
                              params: query_string_params,
         | 
| 625 | 
            +
                              method_name: "create_processor",
         | 
| 587 626 | 
             
                              options: options
         | 
| 588 627 | 
             
                            )
         | 
| 589 628 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 590 629 | 
             
                            result = ::Google::Cloud::DocumentAI::V1beta3::Processor.decode_json response.body, ignore_unknown_fields: true
         | 
| 591 | 
            -
             | 
| 592 | 
            -
             | 
| 593 | 
            -
             | 
| 630 | 
            +
                            catch :response do
         | 
| 631 | 
            +
                              yield result, operation if block_given?
         | 
| 632 | 
            +
                              result
         | 
| 633 | 
            +
                            end
         | 
| 594 634 | 
             
                          end
         | 
| 595 635 |  | 
| 596 636 | 
             
                          ##
         | 
| @@ -619,16 +659,18 @@ module Google | |
| 619 659 |  | 
| 620 660 | 
             
                            response = @client_stub.make_http_request(
         | 
| 621 661 | 
             
                              verb,
         | 
| 622 | 
            -
                              uri: | 
| 623 | 
            -
                              body: | 
| 624 | 
            -
                              params: | 
| 662 | 
            +
                              uri: uri,
         | 
| 663 | 
            +
                              body: body || "",
         | 
| 664 | 
            +
                              params: query_string_params,
         | 
| 665 | 
            +
                              method_name: "delete_processor",
         | 
| 625 666 | 
             
                              options: options
         | 
| 626 667 | 
             
                            )
         | 
| 627 668 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 628 669 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 629 | 
            -
             | 
| 630 | 
            -
             | 
| 631 | 
            -
             | 
| 670 | 
            +
                            catch :response do
         | 
| 671 | 
            +
                              yield result, operation if block_given?
         | 
| 672 | 
            +
                              result
         | 
| 673 | 
            +
                            end
         | 
| 632 674 | 
             
                          end
         | 
| 633 675 |  | 
| 634 676 | 
             
                          ##
         | 
| @@ -657,16 +699,18 @@ module Google | |
| 657 699 |  | 
| 658 700 | 
             
                            response = @client_stub.make_http_request(
         | 
| 659 701 | 
             
                              verb,
         | 
| 660 | 
            -
                              uri: | 
| 661 | 
            -
                              body: | 
| 662 | 
            -
                              params: | 
| 702 | 
            +
                              uri: uri,
         | 
| 703 | 
            +
                              body: body || "",
         | 
| 704 | 
            +
                              params: query_string_params,
         | 
| 705 | 
            +
                              method_name: "enable_processor",
         | 
| 663 706 | 
             
                              options: options
         | 
| 664 707 | 
             
                            )
         | 
| 665 708 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 666 709 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 667 | 
            -
             | 
| 668 | 
            -
             | 
| 669 | 
            -
             | 
| 710 | 
            +
                            catch :response do
         | 
| 711 | 
            +
                              yield result, operation if block_given?
         | 
| 712 | 
            +
                              result
         | 
| 713 | 
            +
                            end
         | 
| 670 714 | 
             
                          end
         | 
| 671 715 |  | 
| 672 716 | 
             
                          ##
         | 
| @@ -695,16 +739,18 @@ module Google | |
| 695 739 |  | 
| 696 740 | 
             
                            response = @client_stub.make_http_request(
         | 
| 697 741 | 
             
                              verb,
         | 
| 698 | 
            -
                              uri: | 
| 699 | 
            -
                              body: | 
| 700 | 
            -
                              params: | 
| 742 | 
            +
                              uri: uri,
         | 
| 743 | 
            +
                              body: body || "",
         | 
| 744 | 
            +
                              params: query_string_params,
         | 
| 745 | 
            +
                              method_name: "disable_processor",
         | 
| 701 746 | 
             
                              options: options
         | 
| 702 747 | 
             
                            )
         | 
| 703 748 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 704 749 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 705 | 
            -
             | 
| 706 | 
            -
             | 
| 707 | 
            -
             | 
| 750 | 
            +
                            catch :response do
         | 
| 751 | 
            +
                              yield result, operation if block_given?
         | 
| 752 | 
            +
                              result
         | 
| 753 | 
            +
                            end
         | 
| 708 754 | 
             
                          end
         | 
| 709 755 |  | 
| 710 756 | 
             
                          ##
         | 
| @@ -733,16 +779,18 @@ module Google | |
| 733 779 |  | 
| 734 780 | 
             
                            response = @client_stub.make_http_request(
         | 
| 735 781 | 
             
                              verb,
         | 
| 736 | 
            -
                              uri: | 
| 737 | 
            -
                              body: | 
| 738 | 
            -
                              params: | 
| 782 | 
            +
                              uri: uri,
         | 
| 783 | 
            +
                              body: body || "",
         | 
| 784 | 
            +
                              params: query_string_params,
         | 
| 785 | 
            +
                              method_name: "set_default_processor_version",
         | 
| 739 786 | 
             
                              options: options
         | 
| 740 787 | 
             
                            )
         | 
| 741 788 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 742 789 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 743 | 
            -
             | 
| 744 | 
            -
             | 
| 745 | 
            -
             | 
| 790 | 
            +
                            catch :response do
         | 
| 791 | 
            +
                              yield result, operation if block_given?
         | 
| 792 | 
            +
                              result
         | 
| 793 | 
            +
                            end
         | 
| 746 794 | 
             
                          end
         | 
| 747 795 |  | 
| 748 796 | 
             
                          ##
         | 
| @@ -771,16 +819,18 @@ module Google | |
| 771 819 |  | 
| 772 820 | 
             
                            response = @client_stub.make_http_request(
         | 
| 773 821 | 
             
                              verb,
         | 
| 774 | 
            -
                              uri: | 
| 775 | 
            -
                              body: | 
| 776 | 
            -
                              params: | 
| 822 | 
            +
                              uri: uri,
         | 
| 823 | 
            +
                              body: body || "",
         | 
| 824 | 
            +
                              params: query_string_params,
         | 
| 825 | 
            +
                              method_name: "review_document",
         | 
| 777 826 | 
             
                              options: options
         | 
| 778 827 | 
             
                            )
         | 
| 779 828 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 780 829 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 781 | 
            -
             | 
| 782 | 
            -
             | 
| 783 | 
            -
             | 
| 830 | 
            +
                            catch :response do
         | 
| 831 | 
            +
                              yield result, operation if block_given?
         | 
| 832 | 
            +
                              result
         | 
| 833 | 
            +
                            end
         | 
| 784 834 | 
             
                          end
         | 
| 785 835 |  | 
| 786 836 | 
             
                          ##
         | 
| @@ -809,16 +859,18 @@ module Google | |
| 809 859 |  | 
| 810 860 | 
             
                            response = @client_stub.make_http_request(
         | 
| 811 861 | 
             
                              verb,
         | 
| 812 | 
            -
                              uri: | 
| 813 | 
            -
                              body: | 
| 814 | 
            -
                              params: | 
| 862 | 
            +
                              uri: uri,
         | 
| 863 | 
            +
                              body: body || "",
         | 
| 864 | 
            +
                              params: query_string_params,
         | 
| 865 | 
            +
                              method_name: "evaluate_processor_version",
         | 
| 815 866 | 
             
                              options: options
         | 
| 816 867 | 
             
                            )
         | 
| 817 868 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 818 869 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 819 | 
            -
             | 
| 820 | 
            -
             | 
| 821 | 
            -
             | 
| 870 | 
            +
                            catch :response do
         | 
| 871 | 
            +
                              yield result, operation if block_given?
         | 
| 872 | 
            +
                              result
         | 
| 873 | 
            +
                            end
         | 
| 822 874 | 
             
                          end
         | 
| 823 875 |  | 
| 824 876 | 
             
                          ##
         | 
| @@ -847,16 +899,18 @@ module Google | |
| 847 899 |  | 
| 848 900 | 
             
                            response = @client_stub.make_http_request(
         | 
| 849 901 | 
             
                              verb,
         | 
| 850 | 
            -
                              uri: | 
| 851 | 
            -
                              body: | 
| 852 | 
            -
                              params: | 
| 902 | 
            +
                              uri: uri,
         | 
| 903 | 
            +
                              body: body || "",
         | 
| 904 | 
            +
                              params: query_string_params,
         | 
| 905 | 
            +
                              method_name: "get_evaluation",
         | 
| 853 906 | 
             
                              options: options
         | 
| 854 907 | 
             
                            )
         | 
| 855 908 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 856 909 | 
             
                            result = ::Google::Cloud::DocumentAI::V1beta3::Evaluation.decode_json response.body, ignore_unknown_fields: true
         | 
| 857 | 
            -
             | 
| 858 | 
            -
             | 
| 859 | 
            -
             | 
| 910 | 
            +
                            catch :response do
         | 
| 911 | 
            +
                              yield result, operation if block_given?
         | 
| 912 | 
            +
                              result
         | 
| 913 | 
            +
                            end
         | 
| 860 914 | 
             
                          end
         | 
| 861 915 |  | 
| 862 916 | 
             
                          ##
         | 
| @@ -885,16 +939,18 @@ module Google | |
| 885 939 |  | 
| 886 940 | 
             
                            response = @client_stub.make_http_request(
         | 
| 887 941 | 
             
                              verb,
         | 
| 888 | 
            -
                              uri: | 
| 889 | 
            -
                              body: | 
| 890 | 
            -
                              params: | 
| 942 | 
            +
                              uri: uri,
         | 
| 943 | 
            +
                              body: body || "",
         | 
| 944 | 
            +
                              params: query_string_params,
         | 
| 945 | 
            +
                              method_name: "list_evaluations",
         | 
| 891 946 | 
             
                              options: options
         | 
| 892 947 | 
             
                            )
         | 
| 893 948 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 894 949 | 
             
                            result = ::Google::Cloud::DocumentAI::V1beta3::ListEvaluationsResponse.decode_json response.body, ignore_unknown_fields: true
         | 
| 895 | 
            -
             | 
| 896 | 
            -
             | 
| 897 | 
            -
             | 
| 950 | 
            +
                            catch :response do
         | 
| 951 | 
            +
                              yield result, operation if block_given?
         | 
| 952 | 
            +
                              result
         | 
| 953 | 
            +
                            end
         | 
| 898 954 | 
             
                          end
         | 
| 899 955 |  | 
| 900 956 | 
             
                          ##
         | 
| @@ -923,16 +979,18 @@ module Google | |
| 923 979 |  | 
| 924 980 | 
             
                            response = @client_stub.make_http_request(
         | 
| 925 981 | 
             
                              verb,
         | 
| 926 | 
            -
                              uri: | 
| 927 | 
            -
                              body: | 
| 928 | 
            -
                              params: | 
| 982 | 
            +
                              uri: uri,
         | 
| 983 | 
            +
                              body: body || "",
         | 
| 984 | 
            +
                              params: query_string_params,
         | 
| 985 | 
            +
                              method_name: "import_processor_version",
         | 
| 929 986 | 
             
                              options: options
         | 
| 930 987 | 
             
                            )
         | 
| 931 988 | 
             
                            operation = ::Gapic::Rest::TransportOperation.new response
         | 
| 932 989 | 
             
                            result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true
         | 
| 933 | 
            -
             | 
| 934 | 
            -
             | 
| 935 | 
            -
             | 
| 990 | 
            +
                            catch :response do
         | 
| 991 | 
            +
                              yield result, operation if block_given?
         | 
| 992 | 
            +
                              result
         | 
| 993 | 
            +
                            end
         | 
| 936 994 | 
             
                          end
         | 
| 937 995 |  | 
| 938 996 | 
             
                          ##
         |