google-cloud-dataplex-v1 0.10.1 → 0.11.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/lib/google/cloud/dataplex/v1/content_service/client.rb +10 -1
- data/lib/google/cloud/dataplex/v1/content_service/rest/client.rb +132 -0
- data/lib/google/cloud/dataplex/v1/data_scan_service/client.rb +10 -1
- data/lib/google/cloud/dataplex/v1/data_scan_service/operations.rb +10 -1
- data/lib/google/cloud/dataplex/v1/data_scan_service/rest/client.rb +157 -0
- data/lib/google/cloud/dataplex/v1/data_scan_service/rest/operations.rb +75 -0
- data/lib/google/cloud/dataplex/v1/data_taxonomy_service/client.rb +10 -1
- data/lib/google/cloud/dataplex/v1/data_taxonomy_service/operations.rb +10 -1
- data/lib/google/cloud/dataplex/v1/data_taxonomy_service/rest/client.rb +315 -0
- data/lib/google/cloud/dataplex/v1/data_taxonomy_service/rest/operations.rb +75 -0
- data/lib/google/cloud/dataplex/v1/dataplex_service/client.rb +10 -1
- data/lib/google/cloud/dataplex/v1/dataplex_service/operations.rb +10 -1
- data/lib/google/cloud/dataplex/v1/dataplex_service/rest/client.rb +673 -0
- data/lib/google/cloud/dataplex/v1/dataplex_service/rest/operations.rb +75 -0
- data/lib/google/cloud/dataplex/v1/metadata_service/client.rb +10 -1
- data/lib/google/cloud/dataplex/v1/metadata_service/rest/client.rb +152 -0
- data/lib/google/cloud/dataplex/v1/version.rb +1 -1
- data/proto_docs/google/api/field_behavior.rb +14 -0
- metadata +5 -5
| @@ -332,6 +332,29 @@ module Google | |
| 332 332 | 
             
                          # @return [::Gapic::Operation]
         | 
| 333 333 | 
             
                          #
         | 
| 334 334 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 335 | 
            +
                          #
         | 
| 336 | 
            +
                          # @example Basic example
         | 
| 337 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 338 | 
            +
                          #
         | 
| 339 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 340 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 341 | 
            +
                          #
         | 
| 342 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 343 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::CreateLakeRequest.new
         | 
| 344 | 
            +
                          #
         | 
| 345 | 
            +
                          #   # Call the create_lake method.
         | 
| 346 | 
            +
                          #   result = client.create_lake request
         | 
| 347 | 
            +
                          #
         | 
| 348 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 349 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 350 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 351 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 352 | 
            +
                          #   if result.response?
         | 
| 353 | 
            +
                          #     p result.response
         | 
| 354 | 
            +
                          #   else
         | 
| 355 | 
            +
                          #     puts "No response received."
         | 
| 356 | 
            +
                          #   end
         | 
| 357 | 
            +
                          #
         | 
| 335 358 | 
             
                          def create_lake request, options = nil
         | 
| 336 359 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 337 360 |  | 
| @@ -401,6 +424,29 @@ module Google | |
| 401 424 | 
             
                          # @return [::Gapic::Operation]
         | 
| 402 425 | 
             
                          #
         | 
| 403 426 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 427 | 
            +
                          #
         | 
| 428 | 
            +
                          # @example Basic example
         | 
| 429 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 430 | 
            +
                          #
         | 
| 431 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 432 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 433 | 
            +
                          #
         | 
| 434 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 435 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::UpdateLakeRequest.new
         | 
| 436 | 
            +
                          #
         | 
| 437 | 
            +
                          #   # Call the update_lake method.
         | 
| 438 | 
            +
                          #   result = client.update_lake request
         | 
| 439 | 
            +
                          #
         | 
| 440 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 441 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 442 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 443 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 444 | 
            +
                          #   if result.response?
         | 
| 445 | 
            +
                          #     p result.response
         | 
| 446 | 
            +
                          #   else
         | 
| 447 | 
            +
                          #     puts "No response received."
         | 
| 448 | 
            +
                          #   end
         | 
| 449 | 
            +
                          #
         | 
| 404 450 | 
             
                          def update_lake request, options = nil
         | 
| 405 451 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 406 452 |  | 
| @@ -466,6 +512,29 @@ module Google | |
| 466 512 | 
             
                          # @return [::Gapic::Operation]
         | 
| 467 513 | 
             
                          #
         | 
| 468 514 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 515 | 
            +
                          #
         | 
| 516 | 
            +
                          # @example Basic example
         | 
| 517 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 518 | 
            +
                          #
         | 
| 519 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 520 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 521 | 
            +
                          #
         | 
| 522 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 523 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::DeleteLakeRequest.new
         | 
| 524 | 
            +
                          #
         | 
| 525 | 
            +
                          #   # Call the delete_lake method.
         | 
| 526 | 
            +
                          #   result = client.delete_lake request
         | 
| 527 | 
            +
                          #
         | 
| 528 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 529 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 530 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 531 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 532 | 
            +
                          #   if result.response?
         | 
| 533 | 
            +
                          #     p result.response
         | 
| 534 | 
            +
                          #   else
         | 
| 535 | 
            +
                          #     puts "No response received."
         | 
| 536 | 
            +
                          #   end
         | 
| 537 | 
            +
                          #
         | 
| 469 538 | 
             
                          def delete_lake request, options = nil
         | 
| 470 539 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 471 540 |  | 
| @@ -543,6 +612,26 @@ module Google | |
| 543 612 | 
             
                          # @return [::Google::Cloud::Dataplex::V1::ListLakesResponse]
         | 
| 544 613 | 
             
                          #
         | 
| 545 614 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 615 | 
            +
                          #
         | 
| 616 | 
            +
                          # @example Basic example
         | 
| 617 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 618 | 
            +
                          #
         | 
| 619 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 620 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 621 | 
            +
                          #
         | 
| 622 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 623 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::ListLakesRequest.new
         | 
| 624 | 
            +
                          #
         | 
| 625 | 
            +
                          #   # Call the list_lakes method.
         | 
| 626 | 
            +
                          #   result = client.list_lakes request
         | 
| 627 | 
            +
                          #
         | 
| 628 | 
            +
                          #   # The returned object is of type Gapic::PagedEnumerable. You can iterate
         | 
| 629 | 
            +
                          #   # over elements, and API calls will be issued to fetch pages as needed.
         | 
| 630 | 
            +
                          #   result.each do |item|
         | 
| 631 | 
            +
                          #     # Each element is of type ::Google::Cloud::Dataplex::V1::Lake.
         | 
| 632 | 
            +
                          #     p item
         | 
| 633 | 
            +
                          #   end
         | 
| 634 | 
            +
                          #
         | 
| 546 635 | 
             
                          def list_lakes request, options = nil
         | 
| 547 636 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 548 637 |  | 
| @@ -606,6 +695,22 @@ module Google | |
| 606 695 | 
             
                          # @return [::Google::Cloud::Dataplex::V1::Lake]
         | 
| 607 696 | 
             
                          #
         | 
| 608 697 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 698 | 
            +
                          #
         | 
| 699 | 
            +
                          # @example Basic example
         | 
| 700 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 701 | 
            +
                          #
         | 
| 702 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 703 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 704 | 
            +
                          #
         | 
| 705 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 706 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::GetLakeRequest.new
         | 
| 707 | 
            +
                          #
         | 
| 708 | 
            +
                          #   # Call the get_lake method.
         | 
| 709 | 
            +
                          #   result = client.get_lake request
         | 
| 710 | 
            +
                          #
         | 
| 711 | 
            +
                          #   # The returned object is of type Google::Cloud::Dataplex::V1::Lake.
         | 
| 712 | 
            +
                          #   p result
         | 
| 713 | 
            +
                          #
         | 
| 609 714 | 
             
                          def get_lake request, options = nil
         | 
| 610 715 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 611 716 |  | 
| @@ -678,6 +783,26 @@ module Google | |
| 678 783 | 
             
                          # @return [::Gapic::Rest::PagedEnumerable<::Google::Cloud::Dataplex::V1::Action>]
         | 
| 679 784 | 
             
                          #
         | 
| 680 785 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 786 | 
            +
                          #
         | 
| 787 | 
            +
                          # @example Basic example
         | 
| 788 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 789 | 
            +
                          #
         | 
| 790 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 791 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 792 | 
            +
                          #
         | 
| 793 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 794 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::ListLakeActionsRequest.new
         | 
| 795 | 
            +
                          #
         | 
| 796 | 
            +
                          #   # Call the list_lake_actions method.
         | 
| 797 | 
            +
                          #   result = client.list_lake_actions request
         | 
| 798 | 
            +
                          #
         | 
| 799 | 
            +
                          #   # The returned object is of type Gapic::PagedEnumerable. You can iterate
         | 
| 800 | 
            +
                          #   # over elements, and API calls will be issued to fetch pages as needed.
         | 
| 801 | 
            +
                          #   result.each do |item|
         | 
| 802 | 
            +
                          #     # Each element is of type ::Google::Cloud::Dataplex::V1::Action.
         | 
| 803 | 
            +
                          #     p item
         | 
| 804 | 
            +
                          #   end
         | 
| 805 | 
            +
                          #
         | 
| 681 806 | 
             
                          def list_lake_actions request, options = nil
         | 
| 682 807 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 683 808 |  | 
| @@ -757,6 +882,29 @@ module Google | |
| 757 882 | 
             
                          # @return [::Gapic::Operation]
         | 
| 758 883 | 
             
                          #
         | 
| 759 884 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 885 | 
            +
                          #
         | 
| 886 | 
            +
                          # @example Basic example
         | 
| 887 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 888 | 
            +
                          #
         | 
| 889 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 890 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 891 | 
            +
                          #
         | 
| 892 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 893 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::CreateZoneRequest.new
         | 
| 894 | 
            +
                          #
         | 
| 895 | 
            +
                          #   # Call the create_zone method.
         | 
| 896 | 
            +
                          #   result = client.create_zone request
         | 
| 897 | 
            +
                          #
         | 
| 898 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 899 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 900 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 901 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 902 | 
            +
                          #   if result.response?
         | 
| 903 | 
            +
                          #     p result.response
         | 
| 904 | 
            +
                          #   else
         | 
| 905 | 
            +
                          #     puts "No response received."
         | 
| 906 | 
            +
                          #   end
         | 
| 907 | 
            +
                          #
         | 
| 760 908 | 
             
                          def create_zone request, options = nil
         | 
| 761 909 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 762 910 |  | 
| @@ -826,6 +974,29 @@ module Google | |
| 826 974 | 
             
                          # @return [::Gapic::Operation]
         | 
| 827 975 | 
             
                          #
         | 
| 828 976 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 977 | 
            +
                          #
         | 
| 978 | 
            +
                          # @example Basic example
         | 
| 979 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 980 | 
            +
                          #
         | 
| 981 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 982 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 983 | 
            +
                          #
         | 
| 984 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 985 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::UpdateZoneRequest.new
         | 
| 986 | 
            +
                          #
         | 
| 987 | 
            +
                          #   # Call the update_zone method.
         | 
| 988 | 
            +
                          #   result = client.update_zone request
         | 
| 989 | 
            +
                          #
         | 
| 990 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 991 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 992 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 993 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 994 | 
            +
                          #   if result.response?
         | 
| 995 | 
            +
                          #     p result.response
         | 
| 996 | 
            +
                          #   else
         | 
| 997 | 
            +
                          #     puts "No response received."
         | 
| 998 | 
            +
                          #   end
         | 
| 999 | 
            +
                          #
         | 
| 829 1000 | 
             
                          def update_zone request, options = nil
         | 
| 830 1001 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 831 1002 |  | 
| @@ -891,6 +1062,29 @@ module Google | |
| 891 1062 | 
             
                          # @return [::Gapic::Operation]
         | 
| 892 1063 | 
             
                          #
         | 
| 893 1064 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 1065 | 
            +
                          #
         | 
| 1066 | 
            +
                          # @example Basic example
         | 
| 1067 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 1068 | 
            +
                          #
         | 
| 1069 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 1070 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 1071 | 
            +
                          #
         | 
| 1072 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 1073 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::DeleteZoneRequest.new
         | 
| 1074 | 
            +
                          #
         | 
| 1075 | 
            +
                          #   # Call the delete_zone method.
         | 
| 1076 | 
            +
                          #   result = client.delete_zone request
         | 
| 1077 | 
            +
                          #
         | 
| 1078 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 1079 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 1080 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 1081 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 1082 | 
            +
                          #   if result.response?
         | 
| 1083 | 
            +
                          #     p result.response
         | 
| 1084 | 
            +
                          #   else
         | 
| 1085 | 
            +
                          #     puts "No response received."
         | 
| 1086 | 
            +
                          #   end
         | 
| 1087 | 
            +
                          #
         | 
| 894 1088 | 
             
                          def delete_zone request, options = nil
         | 
| 895 1089 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 896 1090 |  | 
| @@ -967,6 +1161,26 @@ module Google | |
| 967 1161 | 
             
                          # @return [::Gapic::Rest::PagedEnumerable<::Google::Cloud::Dataplex::V1::Zone>]
         | 
| 968 1162 | 
             
                          #
         | 
| 969 1163 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 1164 | 
            +
                          #
         | 
| 1165 | 
            +
                          # @example Basic example
         | 
| 1166 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 1167 | 
            +
                          #
         | 
| 1168 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 1169 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 1170 | 
            +
                          #
         | 
| 1171 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 1172 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::ListZonesRequest.new
         | 
| 1173 | 
            +
                          #
         | 
| 1174 | 
            +
                          #   # Call the list_zones method.
         | 
| 1175 | 
            +
                          #   result = client.list_zones request
         | 
| 1176 | 
            +
                          #
         | 
| 1177 | 
            +
                          #   # The returned object is of type Gapic::PagedEnumerable. You can iterate
         | 
| 1178 | 
            +
                          #   # over elements, and API calls will be issued to fetch pages as needed.
         | 
| 1179 | 
            +
                          #   result.each do |item|
         | 
| 1180 | 
            +
                          #     # Each element is of type ::Google::Cloud::Dataplex::V1::Zone.
         | 
| 1181 | 
            +
                          #     p item
         | 
| 1182 | 
            +
                          #   end
         | 
| 1183 | 
            +
                          #
         | 
| 970 1184 | 
             
                          def list_zones request, options = nil
         | 
| 971 1185 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 972 1186 |  | 
| @@ -1031,6 +1245,22 @@ module Google | |
| 1031 1245 | 
             
                          # @return [::Google::Cloud::Dataplex::V1::Zone]
         | 
| 1032 1246 | 
             
                          #
         | 
| 1033 1247 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 1248 | 
            +
                          #
         | 
| 1249 | 
            +
                          # @example Basic example
         | 
| 1250 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 1251 | 
            +
                          #
         | 
| 1252 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 1253 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 1254 | 
            +
                          #
         | 
| 1255 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 1256 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::GetZoneRequest.new
         | 
| 1257 | 
            +
                          #
         | 
| 1258 | 
            +
                          #   # Call the get_zone method.
         | 
| 1259 | 
            +
                          #   result = client.get_zone request
         | 
| 1260 | 
            +
                          #
         | 
| 1261 | 
            +
                          #   # The returned object is of type Google::Cloud::Dataplex::V1::Zone.
         | 
| 1262 | 
            +
                          #   p result
         | 
| 1263 | 
            +
                          #
         | 
| 1034 1264 | 
             
                          def get_zone request, options = nil
         | 
| 1035 1265 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1036 1266 |  | 
| @@ -1103,6 +1333,26 @@ module Google | |
| 1103 1333 | 
             
                          # @return [::Gapic::Rest::PagedEnumerable<::Google::Cloud::Dataplex::V1::Action>]
         | 
| 1104 1334 | 
             
                          #
         | 
| 1105 1335 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 1336 | 
            +
                          #
         | 
| 1337 | 
            +
                          # @example Basic example
         | 
| 1338 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 1339 | 
            +
                          #
         | 
| 1340 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 1341 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 1342 | 
            +
                          #
         | 
| 1343 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 1344 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::ListZoneActionsRequest.new
         | 
| 1345 | 
            +
                          #
         | 
| 1346 | 
            +
                          #   # Call the list_zone_actions method.
         | 
| 1347 | 
            +
                          #   result = client.list_zone_actions request
         | 
| 1348 | 
            +
                          #
         | 
| 1349 | 
            +
                          #   # The returned object is of type Gapic::PagedEnumerable. You can iterate
         | 
| 1350 | 
            +
                          #   # over elements, and API calls will be issued to fetch pages as needed.
         | 
| 1351 | 
            +
                          #   result.each do |item|
         | 
| 1352 | 
            +
                          #     # Each element is of type ::Google::Cloud::Dataplex::V1::Action.
         | 
| 1353 | 
            +
                          #     p item
         | 
| 1354 | 
            +
                          #   end
         | 
| 1355 | 
            +
                          #
         | 
| 1106 1356 | 
             
                          def list_zone_actions request, options = nil
         | 
| 1107 1357 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1108 1358 |  | 
| @@ -1181,6 +1431,29 @@ module Google | |
| 1181 1431 | 
             
                          # @return [::Gapic::Operation]
         | 
| 1182 1432 | 
             
                          #
         | 
| 1183 1433 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 1434 | 
            +
                          #
         | 
| 1435 | 
            +
                          # @example Basic example
         | 
| 1436 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 1437 | 
            +
                          #
         | 
| 1438 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 1439 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 1440 | 
            +
                          #
         | 
| 1441 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 1442 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::CreateAssetRequest.new
         | 
| 1443 | 
            +
                          #
         | 
| 1444 | 
            +
                          #   # Call the create_asset method.
         | 
| 1445 | 
            +
                          #   result = client.create_asset request
         | 
| 1446 | 
            +
                          #
         | 
| 1447 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 1448 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 1449 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 1450 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 1451 | 
            +
                          #   if result.response?
         | 
| 1452 | 
            +
                          #     p result.response
         | 
| 1453 | 
            +
                          #   else
         | 
| 1454 | 
            +
                          #     puts "No response received."
         | 
| 1455 | 
            +
                          #   end
         | 
| 1456 | 
            +
                          #
         | 
| 1184 1457 | 
             
                          def create_asset request, options = nil
         | 
| 1185 1458 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1186 1459 |  | 
| @@ -1250,6 +1523,29 @@ module Google | |
| 1250 1523 | 
             
                          # @return [::Gapic::Operation]
         | 
| 1251 1524 | 
             
                          #
         | 
| 1252 1525 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 1526 | 
            +
                          #
         | 
| 1527 | 
            +
                          # @example Basic example
         | 
| 1528 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 1529 | 
            +
                          #
         | 
| 1530 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 1531 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 1532 | 
            +
                          #
         | 
| 1533 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 1534 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::UpdateAssetRequest.new
         | 
| 1535 | 
            +
                          #
         | 
| 1536 | 
            +
                          #   # Call the update_asset method.
         | 
| 1537 | 
            +
                          #   result = client.update_asset request
         | 
| 1538 | 
            +
                          #
         | 
| 1539 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 1540 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 1541 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 1542 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 1543 | 
            +
                          #   if result.response?
         | 
| 1544 | 
            +
                          #     p result.response
         | 
| 1545 | 
            +
                          #   else
         | 
| 1546 | 
            +
                          #     puts "No response received."
         | 
| 1547 | 
            +
                          #   end
         | 
| 1548 | 
            +
                          #
         | 
| 1253 1549 | 
             
                          def update_asset request, options = nil
         | 
| 1254 1550 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1255 1551 |  | 
| @@ -1315,6 +1611,29 @@ module Google | |
| 1315 1611 | 
             
                          # @return [::Gapic::Operation]
         | 
| 1316 1612 | 
             
                          #
         | 
| 1317 1613 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 1614 | 
            +
                          #
         | 
| 1615 | 
            +
                          # @example Basic example
         | 
| 1616 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 1617 | 
            +
                          #
         | 
| 1618 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 1619 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 1620 | 
            +
                          #
         | 
| 1621 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 1622 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::DeleteAssetRequest.new
         | 
| 1623 | 
            +
                          #
         | 
| 1624 | 
            +
                          #   # Call the delete_asset method.
         | 
| 1625 | 
            +
                          #   result = client.delete_asset request
         | 
| 1626 | 
            +
                          #
         | 
| 1627 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 1628 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 1629 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 1630 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 1631 | 
            +
                          #   if result.response?
         | 
| 1632 | 
            +
                          #     p result.response
         | 
| 1633 | 
            +
                          #   else
         | 
| 1634 | 
            +
                          #     puts "No response received."
         | 
| 1635 | 
            +
                          #   end
         | 
| 1636 | 
            +
                          #
         | 
| 1318 1637 | 
             
                          def delete_asset request, options = nil
         | 
| 1319 1638 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1320 1639 |  | 
| @@ -1392,6 +1711,26 @@ module Google | |
| 1392 1711 | 
             
                          # @return [::Gapic::Rest::PagedEnumerable<::Google::Cloud::Dataplex::V1::Asset>]
         | 
| 1393 1712 | 
             
                          #
         | 
| 1394 1713 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 1714 | 
            +
                          #
         | 
| 1715 | 
            +
                          # @example Basic example
         | 
| 1716 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 1717 | 
            +
                          #
         | 
| 1718 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 1719 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 1720 | 
            +
                          #
         | 
| 1721 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 1722 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::ListAssetsRequest.new
         | 
| 1723 | 
            +
                          #
         | 
| 1724 | 
            +
                          #   # Call the list_assets method.
         | 
| 1725 | 
            +
                          #   result = client.list_assets request
         | 
| 1726 | 
            +
                          #
         | 
| 1727 | 
            +
                          #   # The returned object is of type Gapic::PagedEnumerable. You can iterate
         | 
| 1728 | 
            +
                          #   # over elements, and API calls will be issued to fetch pages as needed.
         | 
| 1729 | 
            +
                          #   result.each do |item|
         | 
| 1730 | 
            +
                          #     # Each element is of type ::Google::Cloud::Dataplex::V1::Asset.
         | 
| 1731 | 
            +
                          #     p item
         | 
| 1732 | 
            +
                          #   end
         | 
| 1733 | 
            +
                          #
         | 
| 1395 1734 | 
             
                          def list_assets request, options = nil
         | 
| 1396 1735 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1397 1736 |  | 
| @@ -1456,6 +1795,22 @@ module Google | |
| 1456 1795 | 
             
                          # @return [::Google::Cloud::Dataplex::V1::Asset]
         | 
| 1457 1796 | 
             
                          #
         | 
| 1458 1797 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 1798 | 
            +
                          #
         | 
| 1799 | 
            +
                          # @example Basic example
         | 
| 1800 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 1801 | 
            +
                          #
         | 
| 1802 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 1803 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 1804 | 
            +
                          #
         | 
| 1805 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 1806 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::GetAssetRequest.new
         | 
| 1807 | 
            +
                          #
         | 
| 1808 | 
            +
                          #   # Call the get_asset method.
         | 
| 1809 | 
            +
                          #   result = client.get_asset request
         | 
| 1810 | 
            +
                          #
         | 
| 1811 | 
            +
                          #   # The returned object is of type Google::Cloud::Dataplex::V1::Asset.
         | 
| 1812 | 
            +
                          #   p result
         | 
| 1813 | 
            +
                          #
         | 
| 1459 1814 | 
             
                          def get_asset request, options = nil
         | 
| 1460 1815 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1461 1816 |  | 
| @@ -1528,6 +1883,26 @@ module Google | |
| 1528 1883 | 
             
                          # @return [::Gapic::Rest::PagedEnumerable<::Google::Cloud::Dataplex::V1::Action>]
         | 
| 1529 1884 | 
             
                          #
         | 
| 1530 1885 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 1886 | 
            +
                          #
         | 
| 1887 | 
            +
                          # @example Basic example
         | 
| 1888 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 1889 | 
            +
                          #
         | 
| 1890 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 1891 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 1892 | 
            +
                          #
         | 
| 1893 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 1894 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::ListAssetActionsRequest.new
         | 
| 1895 | 
            +
                          #
         | 
| 1896 | 
            +
                          #   # Call the list_asset_actions method.
         | 
| 1897 | 
            +
                          #   result = client.list_asset_actions request
         | 
| 1898 | 
            +
                          #
         | 
| 1899 | 
            +
                          #   # The returned object is of type Gapic::PagedEnumerable. You can iterate
         | 
| 1900 | 
            +
                          #   # over elements, and API calls will be issued to fetch pages as needed.
         | 
| 1901 | 
            +
                          #   result.each do |item|
         | 
| 1902 | 
            +
                          #     # Each element is of type ::Google::Cloud::Dataplex::V1::Action.
         | 
| 1903 | 
            +
                          #     p item
         | 
| 1904 | 
            +
                          #   end
         | 
| 1905 | 
            +
                          #
         | 
| 1531 1906 | 
             
                          def list_asset_actions request, options = nil
         | 
| 1532 1907 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1533 1908 |  | 
| @@ -1599,6 +1974,29 @@ module Google | |
| 1599 1974 | 
             
                          # @return [::Gapic::Operation]
         | 
| 1600 1975 | 
             
                          #
         | 
| 1601 1976 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 1977 | 
            +
                          #
         | 
| 1978 | 
            +
                          # @example Basic example
         | 
| 1979 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 1980 | 
            +
                          #
         | 
| 1981 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 1982 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 1983 | 
            +
                          #
         | 
| 1984 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 1985 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::CreateTaskRequest.new
         | 
| 1986 | 
            +
                          #
         | 
| 1987 | 
            +
                          #   # Call the create_task method.
         | 
| 1988 | 
            +
                          #   result = client.create_task request
         | 
| 1989 | 
            +
                          #
         | 
| 1990 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 1991 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 1992 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 1993 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 1994 | 
            +
                          #   if result.response?
         | 
| 1995 | 
            +
                          #     p result.response
         | 
| 1996 | 
            +
                          #   else
         | 
| 1997 | 
            +
                          #     puts "No response received."
         | 
| 1998 | 
            +
                          #   end
         | 
| 1999 | 
            +
                          #
         | 
| 1602 2000 | 
             
                          def create_task request, options = nil
         | 
| 1603 2001 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1604 2002 |  | 
| @@ -1668,6 +2066,29 @@ module Google | |
| 1668 2066 | 
             
                          # @return [::Gapic::Operation]
         | 
| 1669 2067 | 
             
                          #
         | 
| 1670 2068 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 2069 | 
            +
                          #
         | 
| 2070 | 
            +
                          # @example Basic example
         | 
| 2071 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 2072 | 
            +
                          #
         | 
| 2073 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 2074 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 2075 | 
            +
                          #
         | 
| 2076 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 2077 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::UpdateTaskRequest.new
         | 
| 2078 | 
            +
                          #
         | 
| 2079 | 
            +
                          #   # Call the update_task method.
         | 
| 2080 | 
            +
                          #   result = client.update_task request
         | 
| 2081 | 
            +
                          #
         | 
| 2082 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 2083 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 2084 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 2085 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 2086 | 
            +
                          #   if result.response?
         | 
| 2087 | 
            +
                          #     p result.response
         | 
| 2088 | 
            +
                          #   else
         | 
| 2089 | 
            +
                          #     puts "No response received."
         | 
| 2090 | 
            +
                          #   end
         | 
| 2091 | 
            +
                          #
         | 
| 1671 2092 | 
             
                          def update_task request, options = nil
         | 
| 1672 2093 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1673 2094 |  | 
| @@ -1732,6 +2153,29 @@ module Google | |
| 1732 2153 | 
             
                          # @return [::Gapic::Operation]
         | 
| 1733 2154 | 
             
                          #
         | 
| 1734 2155 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 2156 | 
            +
                          #
         | 
| 2157 | 
            +
                          # @example Basic example
         | 
| 2158 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 2159 | 
            +
                          #
         | 
| 2160 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 2161 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 2162 | 
            +
                          #
         | 
| 2163 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 2164 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::DeleteTaskRequest.new
         | 
| 2165 | 
            +
                          #
         | 
| 2166 | 
            +
                          #   # Call the delete_task method.
         | 
| 2167 | 
            +
                          #   result = client.delete_task request
         | 
| 2168 | 
            +
                          #
         | 
| 2169 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 2170 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 2171 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 2172 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 2173 | 
            +
                          #   if result.response?
         | 
| 2174 | 
            +
                          #     p result.response
         | 
| 2175 | 
            +
                          #   else
         | 
| 2176 | 
            +
                          #     puts "No response received."
         | 
| 2177 | 
            +
                          #   end
         | 
| 2178 | 
            +
                          #
         | 
| 1735 2179 | 
             
                          def delete_task request, options = nil
         | 
| 1736 2180 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1737 2181 |  | 
| @@ -1808,6 +2252,26 @@ module Google | |
| 1808 2252 | 
             
                          # @return [::Google::Cloud::Dataplex::V1::ListTasksResponse]
         | 
| 1809 2253 | 
             
                          #
         | 
| 1810 2254 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 2255 | 
            +
                          #
         | 
| 2256 | 
            +
                          # @example Basic example
         | 
| 2257 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 2258 | 
            +
                          #
         | 
| 2259 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 2260 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 2261 | 
            +
                          #
         | 
| 2262 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 2263 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::ListTasksRequest.new
         | 
| 2264 | 
            +
                          #
         | 
| 2265 | 
            +
                          #   # Call the list_tasks method.
         | 
| 2266 | 
            +
                          #   result = client.list_tasks request
         | 
| 2267 | 
            +
                          #
         | 
| 2268 | 
            +
                          #   # The returned object is of type Gapic::PagedEnumerable. You can iterate
         | 
| 2269 | 
            +
                          #   # over elements, and API calls will be issued to fetch pages as needed.
         | 
| 2270 | 
            +
                          #   result.each do |item|
         | 
| 2271 | 
            +
                          #     # Each element is of type ::Google::Cloud::Dataplex::V1::Task.
         | 
| 2272 | 
            +
                          #     p item
         | 
| 2273 | 
            +
                          #   end
         | 
| 2274 | 
            +
                          #
         | 
| 1811 2275 | 
             
                          def list_tasks request, options = nil
         | 
| 1812 2276 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1813 2277 |  | 
| @@ -1871,6 +2335,22 @@ module Google | |
| 1871 2335 | 
             
                          # @return [::Google::Cloud::Dataplex::V1::Task]
         | 
| 1872 2336 | 
             
                          #
         | 
| 1873 2337 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 2338 | 
            +
                          #
         | 
| 2339 | 
            +
                          # @example Basic example
         | 
| 2340 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 2341 | 
            +
                          #
         | 
| 2342 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 2343 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 2344 | 
            +
                          #
         | 
| 2345 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 2346 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::GetTaskRequest.new
         | 
| 2347 | 
            +
                          #
         | 
| 2348 | 
            +
                          #   # Call the get_task method.
         | 
| 2349 | 
            +
                          #   result = client.get_task request
         | 
| 2350 | 
            +
                          #
         | 
| 2351 | 
            +
                          #   # The returned object is of type Google::Cloud::Dataplex::V1::Task.
         | 
| 2352 | 
            +
                          #   p result
         | 
| 2353 | 
            +
                          #
         | 
| 1874 2354 | 
             
                          def get_task request, options = nil
         | 
| 1875 2355 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1876 2356 |  | 
| @@ -1943,6 +2423,26 @@ module Google | |
| 1943 2423 | 
             
                          # @return [::Gapic::Rest::PagedEnumerable<::Google::Cloud::Dataplex::V1::Job>]
         | 
| 1944 2424 | 
             
                          #
         | 
| 1945 2425 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 2426 | 
            +
                          #
         | 
| 2427 | 
            +
                          # @example Basic example
         | 
| 2428 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 2429 | 
            +
                          #
         | 
| 2430 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 2431 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 2432 | 
            +
                          #
         | 
| 2433 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 2434 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::ListJobsRequest.new
         | 
| 2435 | 
            +
                          #
         | 
| 2436 | 
            +
                          #   # Call the list_jobs method.
         | 
| 2437 | 
            +
                          #   result = client.list_jobs request
         | 
| 2438 | 
            +
                          #
         | 
| 2439 | 
            +
                          #   # The returned object is of type Gapic::PagedEnumerable. You can iterate
         | 
| 2440 | 
            +
                          #   # over elements, and API calls will be issued to fetch pages as needed.
         | 
| 2441 | 
            +
                          #   result.each do |item|
         | 
| 2442 | 
            +
                          #     # Each element is of type ::Google::Cloud::Dataplex::V1::Job.
         | 
| 2443 | 
            +
                          #     p item
         | 
| 2444 | 
            +
                          #   end
         | 
| 2445 | 
            +
                          #
         | 
| 1946 2446 | 
             
                          def list_jobs request, options = nil
         | 
| 1947 2447 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 1948 2448 |  | 
| @@ -2023,6 +2523,22 @@ module Google | |
| 2023 2523 | 
             
                          # @return [::Google::Cloud::Dataplex::V1::RunTaskResponse]
         | 
| 2024 2524 | 
             
                          #
         | 
| 2025 2525 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 2526 | 
            +
                          #
         | 
| 2527 | 
            +
                          # @example Basic example
         | 
| 2528 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 2529 | 
            +
                          #
         | 
| 2530 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 2531 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 2532 | 
            +
                          #
         | 
| 2533 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 2534 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::RunTaskRequest.new
         | 
| 2535 | 
            +
                          #
         | 
| 2536 | 
            +
                          #   # Call the run_task method.
         | 
| 2537 | 
            +
                          #   result = client.run_task request
         | 
| 2538 | 
            +
                          #
         | 
| 2539 | 
            +
                          #   # The returned object is of type Google::Cloud::Dataplex::V1::RunTaskResponse.
         | 
| 2540 | 
            +
                          #   p result
         | 
| 2541 | 
            +
                          #
         | 
| 2026 2542 | 
             
                          def run_task request, options = nil
         | 
| 2027 2543 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 2028 2544 |  | 
| @@ -2086,6 +2602,22 @@ module Google | |
| 2086 2602 | 
             
                          # @return [::Google::Cloud::Dataplex::V1::Job]
         | 
| 2087 2603 | 
             
                          #
         | 
| 2088 2604 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 2605 | 
            +
                          #
         | 
| 2606 | 
            +
                          # @example Basic example
         | 
| 2607 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 2608 | 
            +
                          #
         | 
| 2609 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 2610 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 2611 | 
            +
                          #
         | 
| 2612 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 2613 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::GetJobRequest.new
         | 
| 2614 | 
            +
                          #
         | 
| 2615 | 
            +
                          #   # Call the get_job method.
         | 
| 2616 | 
            +
                          #   result = client.get_job request
         | 
| 2617 | 
            +
                          #
         | 
| 2618 | 
            +
                          #   # The returned object is of type Google::Cloud::Dataplex::V1::Job.
         | 
| 2619 | 
            +
                          #   p result
         | 
| 2620 | 
            +
                          #
         | 
| 2089 2621 | 
             
                          def get_job request, options = nil
         | 
| 2090 2622 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 2091 2623 |  | 
| @@ -2149,6 +2681,22 @@ module Google | |
| 2149 2681 | 
             
                          # @return [::Google::Protobuf::Empty]
         | 
| 2150 2682 | 
             
                          #
         | 
| 2151 2683 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 2684 | 
            +
                          #
         | 
| 2685 | 
            +
                          # @example Basic example
         | 
| 2686 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 2687 | 
            +
                          #
         | 
| 2688 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 2689 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 2690 | 
            +
                          #
         | 
| 2691 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 2692 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::CancelJobRequest.new
         | 
| 2693 | 
            +
                          #
         | 
| 2694 | 
            +
                          #   # Call the cancel_job method.
         | 
| 2695 | 
            +
                          #   result = client.cancel_job request
         | 
| 2696 | 
            +
                          #
         | 
| 2697 | 
            +
                          #   # The returned object is of type Google::Protobuf::Empty.
         | 
| 2698 | 
            +
                          #   p result
         | 
| 2699 | 
            +
                          #
         | 
| 2152 2700 | 
             
                          def cancel_job request, options = nil
         | 
| 2153 2701 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 2154 2702 |  | 
| @@ -2224,6 +2772,29 @@ module Google | |
| 2224 2772 | 
             
                          # @return [::Gapic::Operation]
         | 
| 2225 2773 | 
             
                          #
         | 
| 2226 2774 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 2775 | 
            +
                          #
         | 
| 2776 | 
            +
                          # @example Basic example
         | 
| 2777 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 2778 | 
            +
                          #
         | 
| 2779 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 2780 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 2781 | 
            +
                          #
         | 
| 2782 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 2783 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::CreateEnvironmentRequest.new
         | 
| 2784 | 
            +
                          #
         | 
| 2785 | 
            +
                          #   # Call the create_environment method.
         | 
| 2786 | 
            +
                          #   result = client.create_environment request
         | 
| 2787 | 
            +
                          #
         | 
| 2788 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 2789 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 2790 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 2791 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 2792 | 
            +
                          #   if result.response?
         | 
| 2793 | 
            +
                          #     p result.response
         | 
| 2794 | 
            +
                          #   else
         | 
| 2795 | 
            +
                          #     puts "No response received."
         | 
| 2796 | 
            +
                          #   end
         | 
| 2797 | 
            +
                          #
         | 
| 2227 2798 | 
             
                          def create_environment request, options = nil
         | 
| 2228 2799 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 2229 2800 |  | 
| @@ -2293,6 +2864,29 @@ module Google | |
| 2293 2864 | 
             
                          # @return [::Gapic::Operation]
         | 
| 2294 2865 | 
             
                          #
         | 
| 2295 2866 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 2867 | 
            +
                          #
         | 
| 2868 | 
            +
                          # @example Basic example
         | 
| 2869 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 2870 | 
            +
                          #
         | 
| 2871 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 2872 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 2873 | 
            +
                          #
         | 
| 2874 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 2875 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::UpdateEnvironmentRequest.new
         | 
| 2876 | 
            +
                          #
         | 
| 2877 | 
            +
                          #   # Call the update_environment method.
         | 
| 2878 | 
            +
                          #   result = client.update_environment request
         | 
| 2879 | 
            +
                          #
         | 
| 2880 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 2881 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 2882 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 2883 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 2884 | 
            +
                          #   if result.response?
         | 
| 2885 | 
            +
                          #     p result.response
         | 
| 2886 | 
            +
                          #   else
         | 
| 2887 | 
            +
                          #     puts "No response received."
         | 
| 2888 | 
            +
                          #   end
         | 
| 2889 | 
            +
                          #
         | 
| 2296 2890 | 
             
                          def update_environment request, options = nil
         | 
| 2297 2891 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 2298 2892 |  | 
| @@ -2358,6 +2952,29 @@ module Google | |
| 2358 2952 | 
             
                          # @return [::Gapic::Operation]
         | 
| 2359 2953 | 
             
                          #
         | 
| 2360 2954 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 2955 | 
            +
                          #
         | 
| 2956 | 
            +
                          # @example Basic example
         | 
| 2957 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 2958 | 
            +
                          #
         | 
| 2959 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 2960 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 2961 | 
            +
                          #
         | 
| 2962 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 2963 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::DeleteEnvironmentRequest.new
         | 
| 2964 | 
            +
                          #
         | 
| 2965 | 
            +
                          #   # Call the delete_environment method.
         | 
| 2966 | 
            +
                          #   result = client.delete_environment request
         | 
| 2967 | 
            +
                          #
         | 
| 2968 | 
            +
                          #   # The returned object is of type Gapic::Operation. You can use it to
         | 
| 2969 | 
            +
                          #   # check the status of an operation, cancel it, or wait for results.
         | 
| 2970 | 
            +
                          #   # Here is how to wait for a response.
         | 
| 2971 | 
            +
                          #   result.wait_until_done! timeout: 60
         | 
| 2972 | 
            +
                          #   if result.response?
         | 
| 2973 | 
            +
                          #     p result.response
         | 
| 2974 | 
            +
                          #   else
         | 
| 2975 | 
            +
                          #     puts "No response received."
         | 
| 2976 | 
            +
                          #   end
         | 
| 2977 | 
            +
                          #
         | 
| 2361 2978 | 
             
                          def delete_environment request, options = nil
         | 
| 2362 2979 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 2363 2980 |  | 
| @@ -2436,6 +3053,26 @@ module Google | |
| 2436 3053 | 
             
                          # @return [::Gapic::Rest::PagedEnumerable<::Google::Cloud::Dataplex::V1::Environment>]
         | 
| 2437 3054 | 
             
                          #
         | 
| 2438 3055 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 3056 | 
            +
                          #
         | 
| 3057 | 
            +
                          # @example Basic example
         | 
| 3058 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 3059 | 
            +
                          #
         | 
| 3060 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 3061 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 3062 | 
            +
                          #
         | 
| 3063 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 3064 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::ListEnvironmentsRequest.new
         | 
| 3065 | 
            +
                          #
         | 
| 3066 | 
            +
                          #   # Call the list_environments method.
         | 
| 3067 | 
            +
                          #   result = client.list_environments request
         | 
| 3068 | 
            +
                          #
         | 
| 3069 | 
            +
                          #   # The returned object is of type Gapic::PagedEnumerable. You can iterate
         | 
| 3070 | 
            +
                          #   # over elements, and API calls will be issued to fetch pages as needed.
         | 
| 3071 | 
            +
                          #   result.each do |item|
         | 
| 3072 | 
            +
                          #     # Each element is of type ::Google::Cloud::Dataplex::V1::Environment.
         | 
| 3073 | 
            +
                          #     p item
         | 
| 3074 | 
            +
                          #   end
         | 
| 3075 | 
            +
                          #
         | 
| 2439 3076 | 
             
                          def list_environments request, options = nil
         | 
| 2440 3077 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 2441 3078 |  | 
| @@ -2500,6 +3137,22 @@ module Google | |
| 2500 3137 | 
             
                          # @return [::Google::Cloud::Dataplex::V1::Environment]
         | 
| 2501 3138 | 
             
                          #
         | 
| 2502 3139 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 3140 | 
            +
                          #
         | 
| 3141 | 
            +
                          # @example Basic example
         | 
| 3142 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 3143 | 
            +
                          #
         | 
| 3144 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 3145 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 3146 | 
            +
                          #
         | 
| 3147 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 3148 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::GetEnvironmentRequest.new
         | 
| 3149 | 
            +
                          #
         | 
| 3150 | 
            +
                          #   # Call the get_environment method.
         | 
| 3151 | 
            +
                          #   result = client.get_environment request
         | 
| 3152 | 
            +
                          #
         | 
| 3153 | 
            +
                          #   # The returned object is of type Google::Cloud::Dataplex::V1::Environment.
         | 
| 3154 | 
            +
                          #   p result
         | 
| 3155 | 
            +
                          #
         | 
| 2503 3156 | 
             
                          def get_environment request, options = nil
         | 
| 2504 3157 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 2505 3158 |  | 
| @@ -2582,6 +3235,26 @@ module Google | |
| 2582 3235 | 
             
                          # @return [::Gapic::Rest::PagedEnumerable<::Google::Cloud::Dataplex::V1::Session>]
         | 
| 2583 3236 | 
             
                          #
         | 
| 2584 3237 | 
             
                          # @raise [::Google::Cloud::Error] if the REST call is aborted.
         | 
| 3238 | 
            +
                          #
         | 
| 3239 | 
            +
                          # @example Basic example
         | 
| 3240 | 
            +
                          #   require "google/cloud/dataplex/v1"
         | 
| 3241 | 
            +
                          #
         | 
| 3242 | 
            +
                          #   # Create a client object. The client can be reused for multiple calls.
         | 
| 3243 | 
            +
                          #   client = Google::Cloud::Dataplex::V1::DataplexService::Rest::Client.new
         | 
| 3244 | 
            +
                          #
         | 
| 3245 | 
            +
                          #   # Create a request. To set request fields, pass in keyword arguments.
         | 
| 3246 | 
            +
                          #   request = Google::Cloud::Dataplex::V1::ListSessionsRequest.new
         | 
| 3247 | 
            +
                          #
         | 
| 3248 | 
            +
                          #   # Call the list_sessions method.
         | 
| 3249 | 
            +
                          #   result = client.list_sessions request
         | 
| 3250 | 
            +
                          #
         | 
| 3251 | 
            +
                          #   # The returned object is of type Gapic::PagedEnumerable. You can iterate
         | 
| 3252 | 
            +
                          #   # over elements, and API calls will be issued to fetch pages as needed.
         | 
| 3253 | 
            +
                          #   result.each do |item|
         | 
| 3254 | 
            +
                          #     # Each element is of type ::Google::Cloud::Dataplex::V1::Session.
         | 
| 3255 | 
            +
                          #     p item
         | 
| 3256 | 
            +
                          #   end
         | 
| 3257 | 
            +
                          #
         | 
| 2585 3258 | 
             
                          def list_sessions request, options = nil
         | 
| 2586 3259 | 
             
                            raise ::ArgumentError, "request must be provided" if request.nil?
         | 
| 2587 3260 |  |