strongdm 1.0.2 → 1.0.3

data/lib/svc.rb

@@ -1,1309 +1,1331 @@
 # Copyright 2020 StrongDM Inc
-#
+# 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-#
+# 
 #     http://www.apache.org/licenses/LICENSE-2.0
-#
+# 
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-#
+# 
 
 # This file was generated by protogen. DO NOT EDIT.
 
 this_dir = File.expand_path(File.dirname(__FILE__))
-lib_dir = File.join(this_dir, "grpc")
+lib_dir = File.join(this_dir, 'grpc')
 $LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
-require "grpc"
-require "enumerator"
-Dir[File.join(__dir__, "grpc", "*.rb")].each { |file| require file }
-Dir[File.join(__dir__, "models", "*.rb")].each { |file| require file }
+require 'grpc'
+require 'enumerator'
+Dir[File.join(__dir__, 'grpc', '*.rb')].each {|file| require file }
+Dir[File.join(__dir__, 'models', '*.rb')].each {|file| require file }
 
 module SDM
-  # AccountAttachments assign an account to a role.
-  class AccountAttachments
-    def initialize(host, insecure, parent)
-      begin
-        if insecure
-          @stub = V1::AccountAttachments::Stub.new(host, :this_channel_is_insecure)
-        else
-          cred = GRPC::Core::ChannelCredentials.new()
-          @stub = V1::AccountAttachments::Stub.new(host, cred)
+    # AccountAttachments assign an account to a role.
+    class AccountAttachments
+        def initialize(host, insecure, parent)
+            begin
+                if insecure
+                    @stub = V1::AccountAttachments::Stub.new(host, :this_channel_is_insecure)
+                else
+                    cred = GRPC::Core::ChannelCredentials.new()
+                    @stub = V1::AccountAttachments::Stub.new(host, cred)
+                end
+            rescue => exception
+                raise Plumbing::convert_error_to_porcelain(exception)
+            end
+            @parent = parent
         end
-      rescue => exception
-        raise Plumbing::error_to_porcelain(exception)
-      end
-      @parent = parent
-    end
-
-    # Create registers a new AccountAttachment.
-    def create(
-      account_attachment,
-      options: nil,
-      deadline: nil
-    )
-      req = V1::AccountAttachmentCreateRequest.new()
+        # Create registers a new AccountAttachment.
+        def create(
+account_attachment \
+,
+                    options:nil,
+ deadline:nil)
+            req = V1::AccountAttachmentCreateRequest.new()
+			
+            req.account_attachment = Plumbing::convert_account_attachment_to_plumbing(account_attachment)
+            req.options = Plumbing::convert_account_attachment_create_options_to_plumbing(options)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.create(req, metadata: @parent.get_metadata('AccountAttachments.Create', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.account_attachment = Plumbing::account_attachment_to_plumbing(account_attachment)
-      req.options = Plumbing::account_attachment_create_options_to_plumbing(options)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.create(req, metadata: @parent.get_metadata("AccountAttachments.Create", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = AccountAttachmentCreateResponse.new()
+            resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.account_attachment = Plumbing::convert_account_attachment_to_porcelain(plumbing_response.account_attachment)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = AccountAttachmentCreateResponse.new()
-      resp.meta = Plumbing::create_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.account_attachment = Plumbing::account_attachment_to_porcelain(plumbing_response.account_attachment)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Get reads one AccountAttachment by ID.
-    def get(
-      id,
-      deadline: nil
-    )
-      req = V1::AccountAttachmentGetRequest.new()
+        # Get reads one AccountAttachment by ID.
+        def get(
+id \
+,
+ deadline:nil)
+            req = V1::AccountAttachmentGetRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.get(req, metadata: @parent.get_metadata('AccountAttachments.Get', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.get(req, metadata: @parent.get_metadata("AccountAttachments.Get", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = AccountAttachmentGetResponse.new()
+            resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.account_attachment = Plumbing::convert_account_attachment_to_porcelain(plumbing_response.account_attachment)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = AccountAttachmentGetResponse.new()
-      resp.meta = Plumbing::get_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.account_attachment = Plumbing::account_attachment_to_porcelain(plumbing_response.account_attachment)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Delete removes a AccountAttachment by ID.
-    def delete(
-      id,
-      deadline: nil
-    )
-      req = V1::AccountAttachmentDeleteRequest.new()
+        # Delete removes a AccountAttachment by ID.
+        def delete(
+id \
+,
+ deadline:nil)
+            req = V1::AccountAttachmentDeleteRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.delete(req, metadata: @parent.get_metadata('AccountAttachments.Delete', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("AccountAttachments.Delete", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = AccountAttachmentDeleteResponse.new()
+            resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = AccountAttachmentDeleteResponse.new()
-      resp.meta = Plumbing::delete_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # List gets a list of AccountAttachments matching a given set of criteria.
-    def list(
-      filter,
-      *args,
-      deadline: nil
-    )
-      req = V1::AccountAttachmentListRequest.new()
-      req.meta = V1::ListRequestMetadata.new()
-      page_size_option = @parent._test_options["PageSize"]
-      if page_size_option.is_a? Integer
-        req.meta.limit = page_size_option
-      end
-
-      req.filter = Plumbing::quote_filter_args(filter, *args)
-      resp = Enumerator::Generator.new { |g|
-        tries = 0
-        loop do
-          begin
-            plumbing_response = @stub.list(req, metadata: @parent.get_metadata("AccountAttachments.List", req), deadline: deadline)
-          rescue => exception
-            if (@parent.shouldRetry(tries, exception))
-              tries + +@parent.jitterSleep(tries)
-              next
+        # List gets a list of AccountAttachments matching a given set of criteria.
+        def list(
+filter \
+,
+*args,
+ deadline:nil)
+            req = V1::AccountAttachmentListRequest.new()
+            req.meta = V1::ListRequestMetadata.new()
+            page_size_option = @parent._test_options['PageSize']
+            if page_size_option.is_a? Integer
+                req.meta.limit = page_size_option
             end
-            raise Plumbing::error_to_porcelain(exception)
-          end
-          tries = 0
-          plumbing_response.account_attachments.each do |plumbing_item|
-            g.yield Plumbing::account_attachment_to_porcelain(plumbing_item)
-          end
-          break if plumbing_response.meta.next_cursor == ""
-          req.meta.cursor = plumbing_response.meta.next_cursor
+			
+            req.filter = Plumbing::quote_filter_args(filter, *args)
+            resp = Enumerator::Generator.new { |g|
+                tries = 0
+                loop do
+                    begin
+                        plumbing_response = @stub.list(req, metadata: @parent.get_metadata('AccountAttachments.List', req), deadline:deadline)
+                    rescue => exception
+                        if (@parent.shouldRetry(tries, exception))
+                            tries++
+                            @parent.jitterSleep(tries)
+                            next
+                        end
+                        raise Plumbing::convert_error_to_porcelain(exception)
+                    end
+                    tries = 0
+                    plumbing_response.account_attachments.each do |plumbing_item|
+                        g.yield Plumbing::convert_account_attachment_to_porcelain(plumbing_item)
+                    end
+                    break if plumbing_response.meta.next_cursor == ""
+                    req.meta.cursor = plumbing_response.meta.next_cursor
+                end
+            }
+            resp
         end
-      }
-      resp
     end
-  end
-
-  # AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
-  class AccountGrants
-    def initialize(host, insecure, parent)
-      begin
-        if insecure
-          @stub = V1::AccountGrants::Stub.new(host, :this_channel_is_insecure)
-        else
-          cred = GRPC::Core::ChannelCredentials.new()
-          @stub = V1::AccountGrants::Stub.new(host, cred)
+    # AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource.
+    class AccountGrants
+        def initialize(host, insecure, parent)
+            begin
+                if insecure
+                    @stub = V1::AccountGrants::Stub.new(host, :this_channel_is_insecure)
+                else
+                    cred = GRPC::Core::ChannelCredentials.new()
+                    @stub = V1::AccountGrants::Stub.new(host, cred)
+                end
+            rescue => exception
+                raise Plumbing::convert_error_to_porcelain(exception)
+            end
+            @parent = parent
         end
-      rescue => exception
-        raise Plumbing::error_to_porcelain(exception)
-      end
-      @parent = parent
-    end
-
-    # Create registers a new AccountGrant.
-    def create(
-      account_grant,
-      deadline: nil
-    )
-      req = V1::AccountGrantCreateRequest.new()
+        # Create registers a new AccountGrant.
+        def create(
+account_grant \
+,
+ deadline:nil)
+            req = V1::AccountGrantCreateRequest.new()
+			
+            req.account_grant = Plumbing::convert_account_grant_to_plumbing(account_grant)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.create(req, metadata: @parent.get_metadata('AccountGrants.Create', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.account_grant = Plumbing::account_grant_to_plumbing(account_grant)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.create(req, metadata: @parent.get_metadata("AccountGrants.Create", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = AccountGrantCreateResponse.new()
+            resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.account_grant = Plumbing::convert_account_grant_to_porcelain(plumbing_response.account_grant)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = AccountGrantCreateResponse.new()
-      resp.meta = Plumbing::create_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.account_grant = Plumbing::account_grant_to_porcelain(plumbing_response.account_grant)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Get reads one AccountGrant by ID.
-    def get(
-      id,
-      deadline: nil
-    )
-      req = V1::AccountGrantGetRequest.new()
+        # Get reads one AccountGrant by ID.
+        def get(
+id \
+,
+ deadline:nil)
+            req = V1::AccountGrantGetRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.get(req, metadata: @parent.get_metadata('AccountGrants.Get', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.get(req, metadata: @parent.get_metadata("AccountGrants.Get", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = AccountGrantGetResponse.new()
+            resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.account_grant = Plumbing::convert_account_grant_to_porcelain(plumbing_response.account_grant)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = AccountGrantGetResponse.new()
-      resp.meta = Plumbing::get_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.account_grant = Plumbing::account_grant_to_porcelain(plumbing_response.account_grant)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Delete removes a AccountGrant by ID.
-    def delete(
-      id,
-      deadline: nil
-    )
-      req = V1::AccountGrantDeleteRequest.new()
+        # Delete removes a AccountGrant by ID.
+        def delete(
+id \
+,
+ deadline:nil)
+            req = V1::AccountGrantDeleteRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.delete(req, metadata: @parent.get_metadata('AccountGrants.Delete', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("AccountGrants.Delete", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = AccountGrantDeleteResponse.new()
+            resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = AccountGrantDeleteResponse.new()
-      resp.meta = Plumbing::delete_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # List gets a list of AccountGrants matching a given set of criteria.
-    def list(
-      filter,
-      *args,
-      deadline: nil
-    )
-      req = V1::AccountGrantListRequest.new()
-      req.meta = V1::ListRequestMetadata.new()
-      page_size_option = @parent._test_options["PageSize"]
-      if page_size_option.is_a? Integer
-        req.meta.limit = page_size_option
-      end
-
-      req.filter = Plumbing::quote_filter_args(filter, *args)
-      resp = Enumerator::Generator.new { |g|
-        tries = 0
-        loop do
-          begin
-            plumbing_response = @stub.list(req, metadata: @parent.get_metadata("AccountGrants.List", req), deadline: deadline)
-          rescue => exception
-            if (@parent.shouldRetry(tries, exception))
-              tries + +@parent.jitterSleep(tries)
-              next
+        # List gets a list of AccountGrants matching a given set of criteria.
+        def list(
+filter \
+,
+*args,
+ deadline:nil)
+            req = V1::AccountGrantListRequest.new()
+            req.meta = V1::ListRequestMetadata.new()
+            page_size_option = @parent._test_options['PageSize']
+            if page_size_option.is_a? Integer
+                req.meta.limit = page_size_option
             end
-            raise Plumbing::error_to_porcelain(exception)
-          end
-          tries = 0
-          plumbing_response.account_grants.each do |plumbing_item|
-            g.yield Plumbing::account_grant_to_porcelain(plumbing_item)
-          end
-          break if plumbing_response.meta.next_cursor == ""
-          req.meta.cursor = plumbing_response.meta.next_cursor
+			
+            req.filter = Plumbing::quote_filter_args(filter, *args)
+            resp = Enumerator::Generator.new { |g|
+                tries = 0
+                loop do
+                    begin
+                        plumbing_response = @stub.list(req, metadata: @parent.get_metadata('AccountGrants.List', req), deadline:deadline)
+                    rescue => exception
+                        if (@parent.shouldRetry(tries, exception))
+                            tries++
+                            @parent.jitterSleep(tries)
+                            next
+                        end
+                        raise Plumbing::convert_error_to_porcelain(exception)
+                    end
+                    tries = 0
+                    plumbing_response.account_grants.each do |plumbing_item|
+                        g.yield Plumbing::convert_account_grant_to_porcelain(plumbing_item)
+                    end
+                    break if plumbing_response.meta.next_cursor == ""
+                    req.meta.cursor = plumbing_response.meta.next_cursor
+                end
+            }
+            resp
         end
-      }
-      resp
     end
-  end
-
-  # Accounts are users that have access to strongDM.
-  # There are two types of accounts:
-  # 1. **Regular users:** humans who are authenticated through username and password or SSO
-  # 2. **Service users:** machines that are authneticated using a service token
-  class Accounts
-    def initialize(host, insecure, parent)
-      begin
-        if insecure
-          @stub = V1::Accounts::Stub.new(host, :this_channel_is_insecure)
-        else
-          cred = GRPC::Core::ChannelCredentials.new()
-          @stub = V1::Accounts::Stub.new(host, cred)
+    # Accounts are users that have access to strongDM.
+    # There are two types of accounts:
+    # 1. **Regular users:** humans who are authenticated through username and password or SSO
+    # 2. **Service users:** machines that are authneticated using a service token
+    class Accounts
+        def initialize(host, insecure, parent)
+            begin
+                if insecure
+                    @stub = V1::Accounts::Stub.new(host, :this_channel_is_insecure)
+                else
+                    cred = GRPC::Core::ChannelCredentials.new()
+                    @stub = V1::Accounts::Stub.new(host, cred)
+                end
+            rescue => exception
+                raise Plumbing::convert_error_to_porcelain(exception)
+            end
+            @parent = parent
         end
-      rescue => exception
-        raise Plumbing::error_to_porcelain(exception)
-      end
-      @parent = parent
-    end
-
-    # Create registers a new Account.
-    def create(
-      account,
-      deadline: nil
-    )
-      req = V1::AccountCreateRequest.new()
+        # Create registers a new Account.
+        def create(
+account \
+,
+ deadline:nil)
+            req = V1::AccountCreateRequest.new()
+			
+            req.account = Plumbing::convert_account_to_plumbing(account)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.create(req, metadata: @parent.get_metadata('Accounts.Create', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.account = Plumbing::account_to_plumbing(account)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.create(req, metadata: @parent.get_metadata("Accounts.Create", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = AccountCreateResponse.new()
+            resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.account = Plumbing::convert_account_to_porcelain(plumbing_response.account)
+            resp.token = (plumbing_response.token)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = AccountCreateResponse.new()
-      resp.meta = Plumbing::create_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.account = Plumbing::account_to_porcelain(plumbing_response.account)
-      resp.token = plumbing_response.token
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Get reads one Account by ID.
-    def get(
-      id,
-      deadline: nil
-    )
-      req = V1::AccountGetRequest.new()
+        # Get reads one Account by ID.
+        def get(
+id \
+,
+ deadline:nil)
+            req = V1::AccountGetRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.get(req, metadata: @parent.get_metadata('Accounts.Get', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.get(req, metadata: @parent.get_metadata("Accounts.Get", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = AccountGetResponse.new()
+            resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.account = Plumbing::convert_account_to_porcelain(plumbing_response.account)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = AccountGetResponse.new()
-      resp.meta = Plumbing::get_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.account = Plumbing::account_to_porcelain(plumbing_response.account)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Update patches a Account by ID.
-    def update(
-      account,
-      deadline: nil
-    )
-      req = V1::AccountUpdateRequest.new()
+        # Update patches a Account by ID.
+        def update(
+account \
+,
+ deadline:nil)
+            req = V1::AccountUpdateRequest.new()
+			
+            req.account = Plumbing::convert_account_to_plumbing(account)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.update(req, metadata: @parent.get_metadata('Accounts.Update', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.account = Plumbing::account_to_plumbing(account)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.update(req, metadata: @parent.get_metadata("Accounts.Update", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = AccountUpdateResponse.new()
+            resp.meta = Plumbing::convert_update_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.account = Plumbing::convert_account_to_porcelain(plumbing_response.account)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = AccountUpdateResponse.new()
-      resp.meta = Plumbing::update_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.account = Plumbing::account_to_porcelain(plumbing_response.account)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Delete removes a Account by ID.
-    def delete(
-      id,
-      deadline: nil
-    )
-      req = V1::AccountDeleteRequest.new()
+        # Delete removes a Account by ID.
+        def delete(
+id \
+,
+ deadline:nil)
+            req = V1::AccountDeleteRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.delete(req, metadata: @parent.get_metadata('Accounts.Delete', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("Accounts.Delete", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = AccountDeleteResponse.new()
+            resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = AccountDeleteResponse.new()
-      resp.meta = Plumbing::delete_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # List gets a list of Accounts matching a given set of criteria.
-    def list(
-      filter,
-      *args,
-      deadline: nil
-    )
-      req = V1::AccountListRequest.new()
-      req.meta = V1::ListRequestMetadata.new()
-      page_size_option = @parent._test_options["PageSize"]
-      if page_size_option.is_a? Integer
-        req.meta.limit = page_size_option
-      end
-
-      req.filter = Plumbing::quote_filter_args(filter, *args)
-      resp = Enumerator::Generator.new { |g|
-        tries = 0
-        loop do
-          begin
-            plumbing_response = @stub.list(req, metadata: @parent.get_metadata("Accounts.List", req), deadline: deadline)
-          rescue => exception
-            if (@parent.shouldRetry(tries, exception))
-              tries + +@parent.jitterSleep(tries)
-              next
+        # List gets a list of Accounts matching a given set of criteria.
+        def list(
+filter \
+,
+*args,
+ deadline:nil)
+            req = V1::AccountListRequest.new()
+            req.meta = V1::ListRequestMetadata.new()
+            page_size_option = @parent._test_options['PageSize']
+            if page_size_option.is_a? Integer
+                req.meta.limit = page_size_option
             end
-            raise Plumbing::error_to_porcelain(exception)
-          end
-          tries = 0
-          plumbing_response.accounts.each do |plumbing_item|
-            g.yield Plumbing::account_to_porcelain(plumbing_item)
-          end
-          break if plumbing_response.meta.next_cursor == ""
-          req.meta.cursor = plumbing_response.meta.next_cursor
+			
+            req.filter = Plumbing::quote_filter_args(filter, *args)
+            resp = Enumerator::Generator.new { |g|
+                tries = 0
+                loop do
+                    begin
+                        plumbing_response = @stub.list(req, metadata: @parent.get_metadata('Accounts.List', req), deadline:deadline)
+                    rescue => exception
+                        if (@parent.shouldRetry(tries, exception))
+                            tries++
+                            @parent.jitterSleep(tries)
+                            next
+                        end
+                        raise Plumbing::convert_error_to_porcelain(exception)
+                    end
+                    tries = 0
+                    plumbing_response.accounts.each do |plumbing_item|
+                        g.yield Plumbing::convert_account_to_porcelain(plumbing_item)
+                    end
+                    break if plumbing_response.meta.next_cursor == ""
+                    req.meta.cursor = plumbing_response.meta.next_cursor
+                end
+            }
+            resp
         end
-      }
-      resp
     end
-  end
-
-  # Nodes make up the strongDM network, and allow your users to connect securely to your resources.
-  # There are two types of nodes:
-  # 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall
-  # 1. **Gateways:** a relay that also listens for connections from strongDM clients
-  class Nodes
-    def initialize(host, insecure, parent)
-      begin
-        if insecure
-          @stub = V1::Nodes::Stub.new(host, :this_channel_is_insecure)
-        else
-          cred = GRPC::Core::ChannelCredentials.new()
-          @stub = V1::Nodes::Stub.new(host, cred)
+    # Nodes make up the strongDM network, and allow your users to connect securely to your resources.
+    # There are two types of nodes:
+    # 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall
+    # 1. **Gateways:** a relay that also listens for connections from strongDM clients
+    class Nodes
+        def initialize(host, insecure, parent)
+            begin
+                if insecure
+                    @stub = V1::Nodes::Stub.new(host, :this_channel_is_insecure)
+                else
+                    cred = GRPC::Core::ChannelCredentials.new()
+                    @stub = V1::Nodes::Stub.new(host, cred)
+                end
+            rescue => exception
+                raise Plumbing::convert_error_to_porcelain(exception)
+            end
+            @parent = parent
         end
-      rescue => exception
-        raise Plumbing::error_to_porcelain(exception)
-      end
-      @parent = parent
-    end
-
-    # Create registers a new Node.
-    def create(
-      node,
-      deadline: nil
-    )
-      req = V1::NodeCreateRequest.new()
+        # Create registers a new Node.
+        def create(
+node \
+,
+ deadline:nil)
+            req = V1::NodeCreateRequest.new()
+			
+            req.node = Plumbing::convert_node_to_plumbing(node)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.create(req, metadata: @parent.get_metadata('Nodes.Create', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.node = Plumbing::node_to_plumbing(node)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.create(req, metadata: @parent.get_metadata("Nodes.Create", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = NodeCreateResponse.new()
+            resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.node = Plumbing::convert_node_to_porcelain(plumbing_response.node)
+            resp.token = (plumbing_response.token)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = NodeCreateResponse.new()
-      resp.meta = Plumbing::create_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.node = Plumbing::node_to_porcelain(plumbing_response.node)
-      resp.token = plumbing_response.token
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Get reads one Node by ID.
-    def get(
-      id,
-      deadline: nil
-    )
-      req = V1::NodeGetRequest.new()
+        # Get reads one Node by ID.
+        def get(
+id \
+,
+ deadline:nil)
+            req = V1::NodeGetRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.get(req, metadata: @parent.get_metadata('Nodes.Get', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.get(req, metadata: @parent.get_metadata("Nodes.Get", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = NodeGetResponse.new()
+            resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.node = Plumbing::convert_node_to_porcelain(plumbing_response.node)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = NodeGetResponse.new()
-      resp.meta = Plumbing::get_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.node = Plumbing::node_to_porcelain(plumbing_response.node)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Update patches a Node by ID.
-    def update(
-      node,
-      deadline: nil
-    )
-      req = V1::NodeUpdateRequest.new()
+        # Update patches a Node by ID.
+        def update(
+node \
+,
+ deadline:nil)
+            req = V1::NodeUpdateRequest.new()
+			
+            req.node = Plumbing::convert_node_to_plumbing(node)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.update(req, metadata: @parent.get_metadata('Nodes.Update', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.node = Plumbing::node_to_plumbing(node)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.update(req, metadata: @parent.get_metadata("Nodes.Update", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = NodeUpdateResponse.new()
+            resp.meta = Plumbing::convert_update_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.node = Plumbing::convert_node_to_porcelain(plumbing_response.node)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = NodeUpdateResponse.new()
-      resp.meta = Plumbing::update_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.node = Plumbing::node_to_porcelain(plumbing_response.node)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Delete removes a Node by ID.
-    def delete(
-      id,
-      deadline: nil
-    )
-      req = V1::NodeDeleteRequest.new()
+        # Delete removes a Node by ID.
+        def delete(
+id \
+,
+ deadline:nil)
+            req = V1::NodeDeleteRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.delete(req, metadata: @parent.get_metadata('Nodes.Delete', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("Nodes.Delete", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = NodeDeleteResponse.new()
+            resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = NodeDeleteResponse.new()
-      resp.meta = Plumbing::delete_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # List gets a list of Nodes matching a given set of criteria.
-    def list(
-      filter,
-      *args,
-      deadline: nil
-    )
-      req = V1::NodeListRequest.new()
-      req.meta = V1::ListRequestMetadata.new()
-      page_size_option = @parent._test_options["PageSize"]
-      if page_size_option.is_a? Integer
-        req.meta.limit = page_size_option
-      end
-
-      req.filter = Plumbing::quote_filter_args(filter, *args)
-      resp = Enumerator::Generator.new { |g|
-        tries = 0
-        loop do
-          begin
-            plumbing_response = @stub.list(req, metadata: @parent.get_metadata("Nodes.List", req), deadline: deadline)
-          rescue => exception
-            if (@parent.shouldRetry(tries, exception))
-              tries + +@parent.jitterSleep(tries)
-              next
+        # List gets a list of Nodes matching a given set of criteria.
+        def list(
+filter \
+,
+*args,
+ deadline:nil)
+            req = V1::NodeListRequest.new()
+            req.meta = V1::ListRequestMetadata.new()
+            page_size_option = @parent._test_options['PageSize']
+            if page_size_option.is_a? Integer
+                req.meta.limit = page_size_option
             end
-            raise Plumbing::error_to_porcelain(exception)
-          end
-          tries = 0
-          plumbing_response.nodes.each do |plumbing_item|
-            g.yield Plumbing::node_to_porcelain(plumbing_item)
-          end
-          break if plumbing_response.meta.next_cursor == ""
-          req.meta.cursor = plumbing_response.meta.next_cursor
+			
+            req.filter = Plumbing::quote_filter_args(filter, *args)
+            resp = Enumerator::Generator.new { |g|
+                tries = 0
+                loop do
+                    begin
+                        plumbing_response = @stub.list(req, metadata: @parent.get_metadata('Nodes.List', req), deadline:deadline)
+                    rescue => exception
+                        if (@parent.shouldRetry(tries, exception))
+                            tries++
+                            @parent.jitterSleep(tries)
+                            next
+                        end
+                        raise Plumbing::convert_error_to_porcelain(exception)
+                    end
+                    tries = 0
+                    plumbing_response.nodes.each do |plumbing_item|
+                        g.yield Plumbing::convert_node_to_porcelain(plumbing_item)
+                    end
+                    break if plumbing_response.meta.next_cursor == ""
+                    req.meta.cursor = plumbing_response.meta.next_cursor
+                end
+            }
+            resp
         end
-      }
-      resp
     end
-  end
 
-  class Resources
-    def initialize(host, insecure, parent)
-      begin
-        if insecure
-          @stub = V1::Resources::Stub.new(host, :this_channel_is_insecure)
-        else
-          cred = GRPC::Core::ChannelCredentials.new()
-          @stub = V1::Resources::Stub.new(host, cred)
+    class Resources
+        def initialize(host, insecure, parent)
+            begin
+                if insecure
+                    @stub = V1::Resources::Stub.new(host, :this_channel_is_insecure)
+                else
+                    cred = GRPC::Core::ChannelCredentials.new()
+                    @stub = V1::Resources::Stub.new(host, cred)
+                end
+            rescue => exception
+                raise Plumbing::convert_error_to_porcelain(exception)
+            end
+            @parent = parent
         end
-      rescue => exception
-        raise Plumbing::error_to_porcelain(exception)
-      end
-      @parent = parent
-    end
-
-    # Create registers a new Resource.
-    def create(
-      resource,
-      deadline: nil
-    )
-      req = V1::ResourceCreateRequest.new()
+        # Create registers a new Resource.
+        def create(
+resource \
+,
+ deadline:nil)
+            req = V1::ResourceCreateRequest.new()
+			
+            req.resource = Plumbing::convert_resource_to_plumbing(resource)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.create(req, metadata: @parent.get_metadata('Resources.Create', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.resource = Plumbing::resource_to_plumbing(resource)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.create(req, metadata: @parent.get_metadata("Resources.Create", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = ResourceCreateResponse.new()
+            resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.resource = Plumbing::convert_resource_to_porcelain(plumbing_response.resource)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = ResourceCreateResponse.new()
-      resp.meta = Plumbing::create_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.resource = Plumbing::resource_to_porcelain(plumbing_response.resource)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Get reads one Resource by ID.
-    def get(
-      id,
-      deadline: nil
-    )
-      req = V1::ResourceGetRequest.new()
+        # Get reads one Resource by ID.
+        def get(
+id \
+,
+ deadline:nil)
+            req = V1::ResourceGetRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.get(req, metadata: @parent.get_metadata('Resources.Get', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.get(req, metadata: @parent.get_metadata("Resources.Get", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = ResourceGetResponse.new()
+            resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.resource = Plumbing::convert_resource_to_porcelain(plumbing_response.resource)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = ResourceGetResponse.new()
-      resp.meta = Plumbing::get_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.resource = Plumbing::resource_to_porcelain(plumbing_response.resource)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Update patches a Resource by ID.
-    def update(
-      resource,
-      deadline: nil
-    )
-      req = V1::ResourceUpdateRequest.new()
+        # Update patches a Resource by ID.
+        def update(
+resource \
+,
+ deadline:nil)
+            req = V1::ResourceUpdateRequest.new()
+			
+            req.resource = Plumbing::convert_resource_to_plumbing(resource)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.update(req, metadata: @parent.get_metadata('Resources.Update', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.resource = Plumbing::resource_to_plumbing(resource)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.update(req, metadata: @parent.get_metadata("Resources.Update", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = ResourceUpdateResponse.new()
+            resp.meta = Plumbing::convert_update_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.resource = Plumbing::convert_resource_to_porcelain(plumbing_response.resource)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = ResourceUpdateResponse.new()
-      resp.meta = Plumbing::update_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.resource = Plumbing::resource_to_porcelain(plumbing_response.resource)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Delete removes a Resource by ID.
-    def delete(
-      id,
-      deadline: nil
-    )
-      req = V1::ResourceDeleteRequest.new()
+        # Delete removes a Resource by ID.
+        def delete(
+id \
+,
+ deadline:nil)
+            req = V1::ResourceDeleteRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.delete(req, metadata: @parent.get_metadata('Resources.Delete', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("Resources.Delete", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = ResourceDeleteResponse.new()
+            resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = ResourceDeleteResponse.new()
-      resp.meta = Plumbing::delete_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # List gets a list of Resources matching a given set of criteria.
-    def list(
-      filter,
-      *args,
-      deadline: nil
-    )
-      req = V1::ResourceListRequest.new()
-      req.meta = V1::ListRequestMetadata.new()
-      page_size_option = @parent._test_options["PageSize"]
-      if page_size_option.is_a? Integer
-        req.meta.limit = page_size_option
-      end
-
-      req.filter = Plumbing::quote_filter_args(filter, *args)
-      resp = Enumerator::Generator.new { |g|
-        tries = 0
-        loop do
-          begin
-            plumbing_response = @stub.list(req, metadata: @parent.get_metadata("Resources.List", req), deadline: deadline)
-          rescue => exception
-            if (@parent.shouldRetry(tries, exception))
-              tries + +@parent.jitterSleep(tries)
-              next
+        # List gets a list of Resources matching a given set of criteria.
+        def list(
+filter \
+,
+*args,
+ deadline:nil)
+            req = V1::ResourceListRequest.new()
+            req.meta = V1::ListRequestMetadata.new()
+            page_size_option = @parent._test_options['PageSize']
+            if page_size_option.is_a? Integer
+                req.meta.limit = page_size_option
             end
-            raise Plumbing::error_to_porcelain(exception)
-          end
-          tries = 0
-          plumbing_response.resources.each do |plumbing_item|
-            g.yield Plumbing::resource_to_porcelain(plumbing_item)
-          end
-          break if plumbing_response.meta.next_cursor == ""
-          req.meta.cursor = plumbing_response.meta.next_cursor
+			
+            req.filter = Plumbing::quote_filter_args(filter, *args)
+            resp = Enumerator::Generator.new { |g|
+                tries = 0
+                loop do
+                    begin
+                        plumbing_response = @stub.list(req, metadata: @parent.get_metadata('Resources.List', req), deadline:deadline)
+                    rescue => exception
+                        if (@parent.shouldRetry(tries, exception))
+                            tries++
+                            @parent.jitterSleep(tries)
+                            next
+                        end
+                        raise Plumbing::convert_error_to_porcelain(exception)
+                    end
+                    tries = 0
+                    plumbing_response.resources.each do |plumbing_item|
+                        g.yield Plumbing::convert_resource_to_porcelain(plumbing_item)
+                    end
+                    break if plumbing_response.meta.next_cursor == ""
+                    req.meta.cursor = plumbing_response.meta.next_cursor
+                end
+            }
+            resp
         end
-      }
-      resp
     end
-  end
-
-  # RoleAttachments represent relationships between composite roles and the roles
-  # that make up those composite roles. When a composite role is attached to another
-  # role, the permissions granted to members of the composite role are augmented to
-  # include the permissions granted to members of the attached role.
-  class RoleAttachments
-    def initialize(host, insecure, parent)
-      begin
-        if insecure
-          @stub = V1::RoleAttachments::Stub.new(host, :this_channel_is_insecure)
-        else
-          cred = GRPC::Core::ChannelCredentials.new()
-          @stub = V1::RoleAttachments::Stub.new(host, cred)
+    # RoleAttachments represent relationships between composite roles and the roles
+    # that make up those composite roles. When a composite role is attached to another
+    # role, the permissions granted to members of the composite role are augmented to
+    # include the permissions granted to members of the attached role.
+    class RoleAttachments
+        def initialize(host, insecure, parent)
+            begin
+                if insecure
+                    @stub = V1::RoleAttachments::Stub.new(host, :this_channel_is_insecure)
+                else
+                    cred = GRPC::Core::ChannelCredentials.new()
+                    @stub = V1::RoleAttachments::Stub.new(host, cred)
+                end
+            rescue => exception
+                raise Plumbing::convert_error_to_porcelain(exception)
+            end
+            @parent = parent
         end
-      rescue => exception
-        raise Plumbing::error_to_porcelain(exception)
-      end
-      @parent = parent
-    end
-
-    # Create registers a new RoleAttachment.
-    def create(
-      role_attachment,
-      deadline: nil
-    )
-      req = V1::RoleAttachmentCreateRequest.new()
+        # Create registers a new RoleAttachment.
+        def create(
+role_attachment \
+,
+ deadline:nil)
+            req = V1::RoleAttachmentCreateRequest.new()
+			
+            req.role_attachment = Plumbing::convert_role_attachment_to_plumbing(role_attachment)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.create(req, metadata: @parent.get_metadata('RoleAttachments.Create', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.role_attachment = Plumbing::role_attachment_to_plumbing(role_attachment)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.create(req, metadata: @parent.get_metadata("RoleAttachments.Create", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = RoleAttachmentCreateResponse.new()
+            resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.role_attachment = Plumbing::convert_role_attachment_to_porcelain(plumbing_response.role_attachment)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = RoleAttachmentCreateResponse.new()
-      resp.meta = Plumbing::create_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.role_attachment = Plumbing::role_attachment_to_porcelain(plumbing_response.role_attachment)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Get reads one RoleAttachment by ID.
-    def get(
-      id,
-      deadline: nil
-    )
-      req = V1::RoleAttachmentGetRequest.new()
+        # Get reads one RoleAttachment by ID.
+        def get(
+id \
+,
+ deadline:nil)
+            req = V1::RoleAttachmentGetRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.get(req, metadata: @parent.get_metadata('RoleAttachments.Get', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.get(req, metadata: @parent.get_metadata("RoleAttachments.Get", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = RoleAttachmentGetResponse.new()
+            resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.role_attachment = Plumbing::convert_role_attachment_to_porcelain(plumbing_response.role_attachment)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = RoleAttachmentGetResponse.new()
-      resp.meta = Plumbing::get_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.role_attachment = Plumbing::role_attachment_to_porcelain(plumbing_response.role_attachment)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Delete removes a RoleAttachment by ID.
-    def delete(
-      id,
-      deadline: nil
-    )
-      req = V1::RoleAttachmentDeleteRequest.new()
+        # Delete removes a RoleAttachment by ID.
+        def delete(
+id \
+,
+ deadline:nil)
+            req = V1::RoleAttachmentDeleteRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.delete(req, metadata: @parent.get_metadata('RoleAttachments.Delete', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("RoleAttachments.Delete", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = RoleAttachmentDeleteResponse.new()
+            resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = RoleAttachmentDeleteResponse.new()
-      resp.meta = Plumbing::delete_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # List gets a list of RoleAttachments matching a given set of criteria.
-    def list(
-      filter,
-      *args,
-      deadline: nil
-    )
-      req = V1::RoleAttachmentListRequest.new()
-      req.meta = V1::ListRequestMetadata.new()
-      page_size_option = @parent._test_options["PageSize"]
-      if page_size_option.is_a? Integer
-        req.meta.limit = page_size_option
-      end
-
-      req.filter = Plumbing::quote_filter_args(filter, *args)
-      resp = Enumerator::Generator.new { |g|
-        tries = 0
-        loop do
-          begin
-            plumbing_response = @stub.list(req, metadata: @parent.get_metadata("RoleAttachments.List", req), deadline: deadline)
-          rescue => exception
-            if (@parent.shouldRetry(tries, exception))
-              tries + +@parent.jitterSleep(tries)
-              next
+        # List gets a list of RoleAttachments matching a given set of criteria.
+        def list(
+filter \
+,
+*args,
+ deadline:nil)
+            req = V1::RoleAttachmentListRequest.new()
+            req.meta = V1::ListRequestMetadata.new()
+            page_size_option = @parent._test_options['PageSize']
+            if page_size_option.is_a? Integer
+                req.meta.limit = page_size_option
             end
-            raise Plumbing::error_to_porcelain(exception)
-          end
-          tries = 0
-          plumbing_response.role_attachments.each do |plumbing_item|
-            g.yield Plumbing::role_attachment_to_porcelain(plumbing_item)
-          end
-          break if plumbing_response.meta.next_cursor == ""
-          req.meta.cursor = plumbing_response.meta.next_cursor
+			
+            req.filter = Plumbing::quote_filter_args(filter, *args)
+            resp = Enumerator::Generator.new { |g|
+                tries = 0
+                loop do
+                    begin
+                        plumbing_response = @stub.list(req, metadata: @parent.get_metadata('RoleAttachments.List', req), deadline:deadline)
+                    rescue => exception
+                        if (@parent.shouldRetry(tries, exception))
+                            tries++
+                            @parent.jitterSleep(tries)
+                            next
+                        end
+                        raise Plumbing::convert_error_to_porcelain(exception)
+                    end
+                    tries = 0
+                    plumbing_response.role_attachments.each do |plumbing_item|
+                        g.yield Plumbing::convert_role_attachment_to_porcelain(plumbing_item)
+                    end
+                    break if plumbing_response.meta.next_cursor == ""
+                    req.meta.cursor = plumbing_response.meta.next_cursor
+                end
+            }
+            resp
         end
-      }
-      resp
     end
-  end
-
-  # RoleGrants represent relationships between composite roles and the roles
-  # that make up those composite roles. When a composite role is attached to another
-  # role, the permissions granted to members of the composite role are augmented to
-  # include the permissions granted to members of the attached role.
-  class RoleGrants
-    def initialize(host, insecure, parent)
-      begin
-        if insecure
-          @stub = V1::RoleGrants::Stub.new(host, :this_channel_is_insecure)
-        else
-          cred = GRPC::Core::ChannelCredentials.new()
-          @stub = V1::RoleGrants::Stub.new(host, cred)
+    # RoleGrants represent relationships between composite roles and the roles
+    # that make up those composite roles. When a composite role is attached to another
+    # role, the permissions granted to members of the composite role are augmented to
+    # include the permissions granted to members of the attached role.
+    class RoleGrants
+        def initialize(host, insecure, parent)
+            begin
+                if insecure
+                    @stub = V1::RoleGrants::Stub.new(host, :this_channel_is_insecure)
+                else
+                    cred = GRPC::Core::ChannelCredentials.new()
+                    @stub = V1::RoleGrants::Stub.new(host, cred)
+                end
+            rescue => exception
+                raise Plumbing::convert_error_to_porcelain(exception)
+            end
+            @parent = parent
         end
-      rescue => exception
-        raise Plumbing::error_to_porcelain(exception)
-      end
-      @parent = parent
-    end
-
-    # Create registers a new RoleGrant.
-    def create(
-      role_grant,
-      deadline: nil
-    )
-      req = V1::RoleGrantCreateRequest.new()
+        # Create registers a new RoleGrant.
+        def create(
+role_grant \
+,
+ deadline:nil)
+            req = V1::RoleGrantCreateRequest.new()
+			
+            req.role_grant = Plumbing::convert_role_grant_to_plumbing(role_grant)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.create(req, metadata: @parent.get_metadata('RoleGrants.Create', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.role_grant = Plumbing::role_grant_to_plumbing(role_grant)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.create(req, metadata: @parent.get_metadata("RoleGrants.Create", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = RoleGrantCreateResponse.new()
+            resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.role_grant = Plumbing::convert_role_grant_to_porcelain(plumbing_response.role_grant)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = RoleGrantCreateResponse.new()
-      resp.meta = Plumbing::create_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.role_grant = Plumbing::role_grant_to_porcelain(plumbing_response.role_grant)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Get reads one RoleGrant by ID.
-    def get(
-      id,
-      deadline: nil
-    )
-      req = V1::RoleGrantGetRequest.new()
+        # Get reads one RoleGrant by ID.
+        def get(
+id \
+,
+ deadline:nil)
+            req = V1::RoleGrantGetRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.get(req, metadata: @parent.get_metadata('RoleGrants.Get', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.get(req, metadata: @parent.get_metadata("RoleGrants.Get", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = RoleGrantGetResponse.new()
+            resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.role_grant = Plumbing::convert_role_grant_to_porcelain(plumbing_response.role_grant)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = RoleGrantGetResponse.new()
-      resp.meta = Plumbing::get_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.role_grant = Plumbing::role_grant_to_porcelain(plumbing_response.role_grant)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Delete removes a RoleGrant by ID.
-    def delete(
-      id,
-      deadline: nil
-    )
-      req = V1::RoleGrantDeleteRequest.new()
+        # Delete removes a RoleGrant by ID.
+        def delete(
+id \
+,
+ deadline:nil)
+            req = V1::RoleGrantDeleteRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.delete(req, metadata: @parent.get_metadata('RoleGrants.Delete', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("RoleGrants.Delete", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = RoleGrantDeleteResponse.new()
+            resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = RoleGrantDeleteResponse.new()
-      resp.meta = Plumbing::delete_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # List gets a list of RoleGrants matching a given set of criteria.
-    def list(
-      filter,
-      *args,
-      deadline: nil
-    )
-      req = V1::RoleGrantListRequest.new()
-      req.meta = V1::ListRequestMetadata.new()
-      page_size_option = @parent._test_options["PageSize"]
-      if page_size_option.is_a? Integer
-        req.meta.limit = page_size_option
-      end
-
-      req.filter = Plumbing::quote_filter_args(filter, *args)
-      resp = Enumerator::Generator.new { |g|
-        tries = 0
-        loop do
-          begin
-            plumbing_response = @stub.list(req, metadata: @parent.get_metadata("RoleGrants.List", req), deadline: deadline)
-          rescue => exception
-            if (@parent.shouldRetry(tries, exception))
-              tries + +@parent.jitterSleep(tries)
-              next
+        # List gets a list of RoleGrants matching a given set of criteria.
+        def list(
+filter \
+,
+*args,
+ deadline:nil)
+            req = V1::RoleGrantListRequest.new()
+            req.meta = V1::ListRequestMetadata.new()
+            page_size_option = @parent._test_options['PageSize']
+            if page_size_option.is_a? Integer
+                req.meta.limit = page_size_option
             end
-            raise Plumbing::error_to_porcelain(exception)
-          end
-          tries = 0
-          plumbing_response.role_grants.each do |plumbing_item|
-            g.yield Plumbing::role_grant_to_porcelain(plumbing_item)
-          end
-          break if plumbing_response.meta.next_cursor == ""
-          req.meta.cursor = plumbing_response.meta.next_cursor
+			
+            req.filter = Plumbing::quote_filter_args(filter, *args)
+            resp = Enumerator::Generator.new { |g|
+                tries = 0
+                loop do
+                    begin
+                        plumbing_response = @stub.list(req, metadata: @parent.get_metadata('RoleGrants.List', req), deadline:deadline)
+                    rescue => exception
+                        if (@parent.shouldRetry(tries, exception))
+                            tries++
+                            @parent.jitterSleep(tries)
+                            next
+                        end
+                        raise Plumbing::convert_error_to_porcelain(exception)
+                    end
+                    tries = 0
+                    plumbing_response.role_grants.each do |plumbing_item|
+                        g.yield Plumbing::convert_role_grant_to_porcelain(plumbing_item)
+                    end
+                    break if plumbing_response.meta.next_cursor == ""
+                    req.meta.cursor = plumbing_response.meta.next_cursor
+                end
+            }
+            resp
         end
-      }
-      resp
     end
-  end
-
-  # Roles are tools for controlling user access to resources. Each Role holds a
-  # list of resources which they grant access to. Composite roles are a special
-  # type of Role which have no resource associations of their own, but instead
-  # grant access to the combined resources associated with a set of child roles.
-  # Each user can be a member of one Role or composite role.
-  class Roles
-    def initialize(host, insecure, parent)
-      begin
-        if insecure
-          @stub = V1::Roles::Stub.new(host, :this_channel_is_insecure)
-        else
-          cred = GRPC::Core::ChannelCredentials.new()
-          @stub = V1::Roles::Stub.new(host, cred)
+    # Roles are tools for controlling user access to resources. Each Role holds a
+    # list of resources which they grant access to. Composite roles are a special
+    # type of Role which have no resource associations of their own, but instead
+    # grant access to the combined resources associated with a set of child roles.
+    # Each user can be a member of one Role or composite role.
+    class Roles
+        def initialize(host, insecure, parent)
+            begin
+                if insecure
+                    @stub = V1::Roles::Stub.new(host, :this_channel_is_insecure)
+                else
+                    cred = GRPC::Core::ChannelCredentials.new()
+                    @stub = V1::Roles::Stub.new(host, cred)
+                end
+            rescue => exception
+                raise Plumbing::convert_error_to_porcelain(exception)
+            end
+            @parent = parent
         end
-      rescue => exception
-        raise Plumbing::error_to_porcelain(exception)
-      end
-      @parent = parent
-    end
-
-    # Create registers a new Role.
-    def create(
-      role,
-      deadline: nil
-    )
-      req = V1::RoleCreateRequest.new()
+        # Create registers a new Role.
+        def create(
+role \
+,
+ deadline:nil)
+            req = V1::RoleCreateRequest.new()
+			
+            req.role = Plumbing::convert_role_to_plumbing(role)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.create(req, metadata: @parent.get_metadata('Roles.Create', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.role = Plumbing::role_to_plumbing(role)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.create(req, metadata: @parent.get_metadata("Roles.Create", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = RoleCreateResponse.new()
+            resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.role = Plumbing::convert_role_to_porcelain(plumbing_response.role)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = RoleCreateResponse.new()
-      resp.meta = Plumbing::create_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.role = Plumbing::role_to_porcelain(plumbing_response.role)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Get reads one Role by ID.
-    def get(
-      id,
-      deadline: nil
-    )
-      req = V1::RoleGetRequest.new()
+        # Get reads one Role by ID.
+        def get(
+id \
+,
+ deadline:nil)
+            req = V1::RoleGetRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.get(req, metadata: @parent.get_metadata('Roles.Get', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.get(req, metadata: @parent.get_metadata("Roles.Get", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = RoleGetResponse.new()
+            resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.role = Plumbing::convert_role_to_porcelain(plumbing_response.role)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = RoleGetResponse.new()
-      resp.meta = Plumbing::get_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.role = Plumbing::role_to_porcelain(plumbing_response.role)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Update patches a Role by ID.
-    def update(
-      role,
-      deadline: nil
-    )
-      req = V1::RoleUpdateRequest.new()
+        # Update patches a Role by ID.
+        def update(
+role \
+,
+ deadline:nil)
+            req = V1::RoleUpdateRequest.new()
+			
+            req.role = Plumbing::convert_role_to_plumbing(role)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.update(req, metadata: @parent.get_metadata('Roles.Update', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.role = Plumbing::role_to_plumbing(role)
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.update(req, metadata: @parent.get_metadata("Roles.Update", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = RoleUpdateResponse.new()
+            resp.meta = Plumbing::convert_update_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.role = Plumbing::convert_role_to_porcelain(plumbing_response.role)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = RoleUpdateResponse.new()
-      resp.meta = Plumbing::update_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.role = Plumbing::role_to_porcelain(plumbing_response.role)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # Delete removes a Role by ID.
-    def delete(
-      id,
-      deadline: nil
-    )
-      req = V1::RoleDeleteRequest.new()
+        # Delete removes a Role by ID.
+        def delete(
+id \
+,
+ deadline:nil)
+            req = V1::RoleDeleteRequest.new()
+			
+            req.id = (id)
+            tries = 0
+            plumbing_response = nil
+            loop do
+                begin
+                    plumbing_response = @stub.delete(req, metadata: @parent.get_metadata('Roles.Delete', req), deadline:deadline)
+                rescue => exception
+                    if (@parent.shouldRetry(tries, exception))
+                        tries++
+                        @parent.jitterSleep(tries)
+                        next
+                    end
+                    raise Plumbing::convert_error_to_porcelain(exception)
+                end
+                break
+            end
 
-      req.id = id
-      tries = 0
-      plumbing_response = nil
-      loop do
-        begin
-          plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("Roles.Delete", req), deadline: deadline)
-        rescue => exception
-          if (@parent.shouldRetry(tries, exception))
-            tries + +@parent.jitterSleep(tries)
-            next
-          end
-          raise Plumbing::error_to_porcelain(exception)
+			
+            resp = RoleDeleteResponse.new()
+            resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
+            resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
+            resp
         end
-        break
-      end
-
-      resp = RoleDeleteResponse.new()
-      resp.meta = Plumbing::delete_response_metadata_to_porcelain(plumbing_response.meta)
-      resp.rate_limit = Plumbing::rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
-      resp
-    end
-
-    # List gets a list of Roles matching a given set of criteria.
-    def list(
-      filter,
-      *args,
-      deadline: nil
-    )
-      req = V1::RoleListRequest.new()
-      req.meta = V1::ListRequestMetadata.new()
-      page_size_option = @parent._test_options["PageSize"]
-      if page_size_option.is_a? Integer
-        req.meta.limit = page_size_option
-      end
-
-      req.filter = Plumbing::quote_filter_args(filter, *args)
-      resp = Enumerator::Generator.new { |g|
-        tries = 0
-        loop do
-          begin
-            plumbing_response = @stub.list(req, metadata: @parent.get_metadata("Roles.List", req), deadline: deadline)
-          rescue => exception
-            if (@parent.shouldRetry(tries, exception))
-              tries + +@parent.jitterSleep(tries)
-              next
+        # List gets a list of Roles matching a given set of criteria.
+        def list(
+filter \
+,
+*args,
+ deadline:nil)
+            req = V1::RoleListRequest.new()
+            req.meta = V1::ListRequestMetadata.new()
+            page_size_option = @parent._test_options['PageSize']
+            if page_size_option.is_a? Integer
+                req.meta.limit = page_size_option
             end
-            raise Plumbing::error_to_porcelain(exception)
-          end
-          tries = 0
-          plumbing_response.roles.each do |plumbing_item|
-            g.yield Plumbing::role_to_porcelain(plumbing_item)
-          end
-          break if plumbing_response.meta.next_cursor == ""
-          req.meta.cursor = plumbing_response.meta.next_cursor
+			
+            req.filter = Plumbing::quote_filter_args(filter, *args)
+            resp = Enumerator::Generator.new { |g|
+                tries = 0
+                loop do
+                    begin
+                        plumbing_response = @stub.list(req, metadata: @parent.get_metadata('Roles.List', req), deadline:deadline)
+                    rescue => exception
+                        if (@parent.shouldRetry(tries, exception))
+                            tries++
+                            @parent.jitterSleep(tries)
+                            next
+                        end
+                        raise Plumbing::convert_error_to_porcelain(exception)
+                    end
+                    tries = 0
+                    plumbing_response.roles.each do |plumbing_item|
+                        g.yield Plumbing::convert_role_to_porcelain(plumbing_item)
+                    end
+                    break if plumbing_response.meta.next_cursor == ""
+                    req.meta.cursor = plumbing_response.meta.next_cursor
+                end
+            }
+            resp
         end
-      }
-      resp
     end
-  end
 end