RubyDoc.info: Module: SDM::Plumbing – Documentation for strongdm (1.0.22)

.convert_account_attachment_create_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 311

def self.convert_account_attachment_create_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountAttachmentCreateResponse.new()
  plumbing.meta = convert_create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.account_attachment = convert_account_attachment_to_plumbing(porcelain.account_attachment) unless porcelain.account_attachment == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_account_attachment_create_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 300

def self.convert_account_attachment_create_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountAttachmentCreateResponse.new()
  porcelain.meta = convert_create_response_metadata_to_porcelain(plumbing.meta)
  porcelain.account_attachment = convert_account_attachment_to_porcelain(plumbing.account_attachment)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_account_attachment_delete_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 386

def self.convert_account_attachment_delete_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountAttachmentDeleteResponse.new()
  plumbing.meta = convert_delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_account_attachment_delete_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 376

def self.convert_account_attachment_delete_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountAttachmentDeleteResponse.new()
  porcelain.meta = convert_delete_response_metadata_to_porcelain(plumbing.meta)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_account_attachment_get_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 349

def self.convert_account_attachment_get_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountAttachmentGetResponse.new()
  plumbing.meta = convert_get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.account_attachment = convert_account_attachment_to_plumbing(porcelain.account_attachment) unless porcelain.account_attachment == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_account_attachment_get_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 338

def self.convert_account_attachment_get_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountAttachmentGetResponse.new()
  porcelain.meta = convert_get_response_metadata_to_porcelain(plumbing.meta)
  porcelain.account_attachment = convert_account_attachment_to_porcelain(plumbing.account_attachment)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_account_attachment_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 423

def self.convert_account_attachment_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountAttachment.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.account_id = (porcelain.account_id) unless porcelain.account_id == nil
  plumbing.role_id = (porcelain.role_id) unless porcelain.role_id == nil
  plumbing
end

.convert_account_attachment_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 412

def self.convert_account_attachment_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountAttachment.new()
  porcelain.id = (plumbing.id)
  porcelain.account_id = (plumbing.account_id)
  porcelain.role_id = (plumbing.role_id)
  porcelain
end

.convert_account_create_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 616

def self.convert_account_create_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountCreateResponse.new()
  plumbing.meta = convert_create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.account = convert_account_to_plumbing(porcelain.account) unless porcelain.account == nil
  plumbing.token = (porcelain.token) unless porcelain.token == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_account_create_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 604

def self.convert_account_create_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountCreateResponse.new()
  porcelain.meta = convert_create_response_metadata_to_porcelain(plumbing.meta)
  porcelain.account = convert_account_to_porcelain(plumbing.account)
  porcelain.token = (plumbing.token)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_account_delete_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 730

def self.convert_account_delete_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountDeleteResponse.new()
  plumbing.meta = convert_delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_account_delete_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 720

def self.convert_account_delete_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountDeleteResponse.new()
  porcelain.meta = convert_delete_response_metadata_to_porcelain(plumbing.meta)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_account_get_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 655

def self.convert_account_get_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountGetResponse.new()
  plumbing.meta = convert_get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.account = convert_account_to_plumbing(porcelain.account) unless porcelain.account == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_account_get_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 644

def self.convert_account_get_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountGetResponse.new()
  porcelain.meta = convert_get_response_metadata_to_porcelain(plumbing.meta)
  porcelain.account = convert_account_to_porcelain(plumbing.account)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_account_grant_create_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 461

def self.convert_account_grant_create_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountGrantCreateResponse.new()
  plumbing.meta = convert_create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.account_grant = convert_account_grant_to_plumbing(porcelain.account_grant) unless porcelain.account_grant == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_account_grant_create_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 450

def self.convert_account_grant_create_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountGrantCreateResponse.new()
  porcelain.meta = convert_create_response_metadata_to_porcelain(plumbing.meta)
  porcelain.account_grant = convert_account_grant_to_porcelain(plumbing.account_grant)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_account_grant_delete_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 536

def self.convert_account_grant_delete_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountGrantDeleteResponse.new()
  plumbing.meta = convert_delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_account_grant_delete_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 526

def self.convert_account_grant_delete_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountGrantDeleteResponse.new()
  porcelain.meta = convert_delete_response_metadata_to_porcelain(plumbing.meta)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_account_grant_get_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 499

def self.convert_account_grant_get_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountGrantGetResponse.new()
  plumbing.meta = convert_get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.account_grant = convert_account_grant_to_plumbing(porcelain.account_grant) unless porcelain.account_grant == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_account_grant_get_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 488

def self.convert_account_grant_get_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountGrantGetResponse.new()
  porcelain.meta = convert_get_response_metadata_to_porcelain(plumbing.meta)
  porcelain.account_grant = convert_account_grant_to_porcelain(plumbing.account_grant)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_account_grant_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 575

def self.convert_account_grant_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountGrant.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.resource_id = (porcelain.resource_id) unless porcelain.resource_id == nil
  plumbing.account_id = (porcelain.account_id) unless porcelain.account_id == nil
  plumbing.start_from = convert_timestamp_to_plumbing(porcelain.start_from) unless porcelain.start_from == nil
  plumbing.valid_until = convert_timestamp_to_plumbing(porcelain.valid_until) unless porcelain.valid_until == nil
  plumbing
end

.convert_account_grant_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 562

def self.convert_account_grant_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountGrant.new()
  porcelain.id = (plumbing.id)
  porcelain.resource_id = (plumbing.resource_id)
  porcelain.account_id = (plumbing.account_id)
  porcelain.start_from = convert_timestamp_to_porcelain(plumbing.start_from)
  porcelain.valid_until = convert_timestamp_to_porcelain(plumbing.valid_until)
  porcelain
end

.convert_account_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 756

def self.convert_account_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Account.new()
  if porcelain.instance_of? User
    plumbing.user = convert_user_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Service
    plumbing.service = convert_service_to_plumbing(porcelain)
  end
  plumbing
end

.convert_account_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 770

def self.convert_account_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  if plumbing.user != nil
    return convert_user_to_porcelain(plumbing.user)
  end
  if plumbing.service != nil
    return convert_service_to_porcelain(plumbing.service)
  end
end

.convert_account_update_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 693

def self.convert_account_update_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AccountUpdateResponse.new()
  plumbing.meta = convert_update_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.account = convert_account_to_plumbing(porcelain.account) unless porcelain.account == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_account_update_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 682

def self.convert_account_update_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AccountUpdateResponse.new()
  porcelain.meta = convert_update_response_metadata_to_porcelain(plumbing.meta)
  porcelain.account = convert_account_to_porcelain(plumbing.account)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_aks_basic_auth_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2681

def self.convert_aks_basic_auth_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AKSBasicAuth.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_aks_basic_auth_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2662

def self.convert_aks_basic_auth_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AKSBasicAuth.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port = (plumbing.port)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_aks_service_account_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2734

def self.convert_aks_service_account_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AKSServiceAccount.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.token = (porcelain.token) unless porcelain.token == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_aks_service_account_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2716

def self.convert_aks_service_account_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AKSServiceAccount.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port = (plumbing.port)
  porcelain.token = (plumbing.token)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_aks_service_account_user_impersonation_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2786

def self.convert_aks_service_account_user_impersonation_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AKSServiceAccountUserImpersonation.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.token = (porcelain.token) unless porcelain.token == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_aks_service_account_user_impersonation_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2768

def self.convert_aks_service_account_user_impersonation_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AKSServiceAccountUserImpersonation.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port = (plumbing.port)
  porcelain.token = (plumbing.token)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_aks_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2570

def self.convert_aks_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AKS.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.certificate_authority = (porcelain.certificate_authority) unless porcelain.certificate_authority == nil
  plumbing.client_certificate = (porcelain.client_certificate) unless porcelain.client_certificate == nil
  plumbing.client_key = (porcelain.client_key) unless porcelain.client_key == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_aks_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2550

def self.convert_aks_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AKS.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port = (plumbing.port)
  porcelain.certificate_authority = (plumbing.certificate_authority)
  porcelain.client_certificate = (plumbing.client_certificate)
  porcelain.client_key = (plumbing.client_key)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_aks_user_impersonation_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2626

def self.convert_aks_user_impersonation_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AKSUserImpersonation.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.certificate_authority = (porcelain.certificate_authority) unless porcelain.certificate_authority == nil
  plumbing.client_certificate = (porcelain.client_certificate) unless porcelain.client_certificate == nil
  plumbing.client_key = (porcelain.client_key) unless porcelain.client_key == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_aks_user_impersonation_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2606

def self.convert_aks_user_impersonation_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AKSUserImpersonation.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port = (plumbing.port)
  porcelain.certificate_authority = (plumbing.certificate_authority)
  porcelain.client_certificate = (plumbing.client_certificate)
  porcelain.client_key = (plumbing.client_key)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_amazon_eks_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2345

def self.convert_amazon_eks_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AmazonEKS.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.endpoint = (porcelain.endpoint) unless porcelain.endpoint == nil
  plumbing.access_key = (porcelain.access_key) unless porcelain.access_key == nil
  plumbing.secret_access_key = (porcelain.secret_access_key) unless porcelain.secret_access_key == nil
  plumbing.certificate_authority = (porcelain.certificate_authority) unless porcelain.certificate_authority == nil
  plumbing.region = (porcelain.region) unless porcelain.region == nil
  plumbing.cluster_name = (porcelain.cluster_name) unless porcelain.cluster_name == nil
  plumbing.role_arn = (porcelain.role_arn) unless porcelain.role_arn == nil
  plumbing.role_external_id = (porcelain.role_external_id) unless porcelain.role_external_id == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_amazon_eks_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2322

def self.convert_amazon_eks_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AmazonEKS.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.endpoint = (plumbing.endpoint)
  porcelain.access_key = (plumbing.access_key)
  porcelain.secret_access_key = (plumbing.secret_access_key)
  porcelain.certificate_authority = (plumbing.certificate_authority)
  porcelain.region = (plumbing.region)
  porcelain.cluster_name = (plumbing.cluster_name)
  porcelain.role_arn = (plumbing.role_arn)
  porcelain.role_external_id = (plumbing.role_external_id)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_amazon_eks_user_impersonation_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2407

def self.convert_amazon_eks_user_impersonation_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AmazonEKSUserImpersonation.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.endpoint = (porcelain.endpoint) unless porcelain.endpoint == nil
  plumbing.access_key = (porcelain.access_key) unless porcelain.access_key == nil
  plumbing.secret_access_key = (porcelain.secret_access_key) unless porcelain.secret_access_key == nil
  plumbing.certificate_authority = (porcelain.certificate_authority) unless porcelain.certificate_authority == nil
  plumbing.region = (porcelain.region) unless porcelain.region == nil
  plumbing.cluster_name = (porcelain.cluster_name) unless porcelain.cluster_name == nil
  plumbing.role_arn = (porcelain.role_arn) unless porcelain.role_arn == nil
  plumbing.role_external_id = (porcelain.role_external_id) unless porcelain.role_external_id == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_amazon_eks_user_impersonation_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2384

def self.convert_amazon_eks_user_impersonation_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AmazonEKSUserImpersonation.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.endpoint = (plumbing.endpoint)
  porcelain.access_key = (plumbing.access_key)
  porcelain.secret_access_key = (plumbing.secret_access_key)
  porcelain.certificate_authority = (plumbing.certificate_authority)
  porcelain.region = (plumbing.region)
  porcelain.cluster_name = (plumbing.cluster_name)
  porcelain.role_arn = (plumbing.role_arn)
  porcelain.role_external_id = (plumbing.role_external_id)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_amazon_es_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1791

def self.convert_amazon_es_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AmazonES.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.region = (porcelain.region) unless porcelain.region == nil
  plumbing.secret_access_key = (porcelain.secret_access_key) unless porcelain.secret_access_key == nil
  plumbing.endpoint = (porcelain.endpoint) unless porcelain.endpoint == nil
  plumbing.access_key = (porcelain.access_key) unless porcelain.access_key == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.role_arn = (porcelain.role_arn) unless porcelain.role_arn == nil
  plumbing.role_external_id = (porcelain.role_external_id) unless porcelain.role_external_id == nil
  plumbing
end

.convert_amazon_es_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1770

def self.convert_amazon_es_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AmazonES.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.region = (plumbing.region)
  porcelain.secret_access_key = (plumbing.secret_access_key)
  porcelain.endpoint = (plumbing.endpoint)
  porcelain.access_key = (plumbing.access_key)
  porcelain.port_override = (plumbing.port_override)
  porcelain.role_arn = (plumbing.role_arn)
  porcelain.role_external_id = (plumbing.role_external_id)
  porcelain
end

.convert_athena_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1345

def self.convert_athena_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Athena.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.access_key = (porcelain.access_key) unless porcelain.access_key == nil
  plumbing.secret_access_key = (porcelain.secret_access_key) unless porcelain.secret_access_key == nil
  plumbing.output = (porcelain.output) unless porcelain.output == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.region = (porcelain.region) unless porcelain.region == nil
  plumbing.role_arn = (porcelain.role_arn) unless porcelain.role_arn == nil
  plumbing.role_external_id = (porcelain.role_external_id) unless porcelain.role_external_id == nil
  plumbing
end

.convert_athena_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1324

def self.convert_athena_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Athena.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.access_key = (plumbing.access_key)
  porcelain.secret_access_key = (plumbing.secret_access_key)
  porcelain.output = (plumbing.output)
  porcelain.port_override = (plumbing.port_override)
  porcelain.region = (plumbing.region)
  porcelain.role_arn = (plumbing.role_arn)
  porcelain.role_external_id = (plumbing.role_external_id)
  porcelain
end

.convert_aurora_mysql_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3188

def self.convert_aurora_mysql_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AuroraMysql.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing
end

.convert_aurora_mysql_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3168

def self.convert_aurora_mysql_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AuroraMysql.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain
end

.convert_aurora_postgres_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3529

def self.convert_aurora_postgres_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AuroraPostgres.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.override_database = (porcelain.override_database) unless porcelain.override_database == nil
  plumbing
end

.convert_aurora_postgres_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3508

def self.convert_aurora_postgres_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AuroraPostgres.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.override_database = (plumbing.override_database)
  porcelain
end

.convert_aws_store_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5442

def self.convert_aws_store_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AWSStore.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.region = (porcelain.region) unless porcelain.region == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing
end

.convert_aws_store_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5430

def self.convert_aws_store_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AWSStore.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.region = (plumbing.region)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain
end

.convert_aws_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1401

def self.convert_aws_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::AWS.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.access_key = (porcelain.access_key) unless porcelain.access_key == nil
  plumbing.secret_access_key = (porcelain.secret_access_key) unless porcelain.secret_access_key == nil
  plumbing.healthcheck_region = (porcelain.healthcheck_region) unless porcelain.healthcheck_region == nil
  plumbing.role_arn = (porcelain.role_arn) unless porcelain.role_arn == nil
  plumbing.role_external_id = (porcelain.role_external_id) unless porcelain.role_external_id == nil
  plumbing
end

.convert_aws_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1382

def self.convert_aws_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = AWS.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.access_key = (plumbing.access_key)
  porcelain.secret_access_key = (plumbing.secret_access_key)
  porcelain.healthcheck_region = (plumbing.healthcheck_region)
  porcelain.role_arn = (plumbing.role_arn)
  porcelain.role_external_id = (plumbing.role_external_id)
  porcelain
end

.convert_big_query_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1455

def self.convert_big_query_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::BigQuery.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.private_key = (porcelain.private_key) unless porcelain.private_key == nil
  plumbing.project = (porcelain.project) unless porcelain.project == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.endpoint = (porcelain.endpoint) unless porcelain.endpoint == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing
end

.convert_big_query_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1436

def self.convert_big_query_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = BigQuery.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.private_key = (plumbing.private_key)
  porcelain.project = (plumbing.project)
  porcelain.port_override = (plumbing.port_override)
  porcelain.endpoint = (plumbing.endpoint)
  porcelain.username = (plumbing.username)
  porcelain
end

.convert_cassandra_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1510

def self.convert_cassandra_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Cassandra.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.tls_required = (porcelain.tls_required) unless porcelain.tls_required == nil
  plumbing
end

.convert_cassandra_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1490

def self.convert_cassandra_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Cassandra.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.tls_required = (plumbing.tls_required)
  porcelain
end

.convert_citus_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3761

def self.convert_citus_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Citus.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.override_database = (porcelain.override_database) unless porcelain.override_database == nil
  plumbing
end

.convert_citus_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3740

def self.convert_citus_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Citus.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.override_database = (plumbing.override_database)
  porcelain
end

.convert_clustrix_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3244

def self.convert_clustrix_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Clustrix.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing
end

.convert_clustrix_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3224

def self.convert_clustrix_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Clustrix.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain
end

.convert_cockroach_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3645

def self.convert_cockroach_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Cockroach.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.override_database = (porcelain.override_database) unless porcelain.override_database == nil
  plumbing
end

.convert_cockroach_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3624

def self.convert_cockroach_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Cockroach.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.override_database = (plumbing.override_database)
  porcelain
end

.convert_control_panel_get_sshca_public_key_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 893

def self.convert_control_panel_get_sshca_public_key_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::ControlPanelGetSSHCAPublicKeyResponse.new()
  plumbing.meta = convert_get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.public_key = (porcelain.public_key) unless porcelain.public_key == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_control_panel_get_sshca_public_key_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 882

def self.convert_control_panel_get_sshca_public_key_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = ControlPanelGetSSHCAPublicKeyResponse.new()
  porcelain.meta = convert_get_response_metadata_to_porcelain(plumbing.meta)
  porcelain.public_key = (plumbing.public_key)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_control_panel_verify_jwt_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 931

def self.convert_control_panel_verify_jwt_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::ControlPanelVerifyJWTResponse.new()
  plumbing.meta = convert_get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.valid = (porcelain.valid) unless porcelain.valid == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_control_panel_verify_jwt_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 920

def self.convert_control_panel_verify_jwt_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = ControlPanelVerifyJWTResponse.new()
  porcelain.meta = convert_get_response_metadata_to_porcelain(plumbing.meta)
  porcelain.valid = (plumbing.valid)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_create_response_metadata_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 104

def self.convert_create_response_metadata_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::CreateResponseMetadata.new()
  plumbing
end

.convert_create_response_metadata_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 96

def self.convert_create_response_metadata_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = CreateResponseMetadata.new()
  porcelain
end

.convert_db_2_i_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1566

def self.convert_db_2_i_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::DB2I.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.tls_required = (porcelain.tls_required) unless porcelain.tls_required == nil
  plumbing
end

.convert_db_2_i_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1546

def self.convert_db_2_i_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = DB2I.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.tls_required = (plumbing.tls_required)
  porcelain
end

.convert_db_2_luw_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1622

def self.convert_db_2_luw_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::DB2LUW.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing
end

.convert_db_2_luw_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1602

def self.convert_db_2_luw_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = DB2LUW.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain
end

.convert_delete_response_metadata_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 200

def self.convert_delete_response_metadata_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::DeleteResponseMetadata.new()
  plumbing
end

.convert_delete_response_metadata_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 192

def self.convert_delete_response_metadata_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = DeleteResponseMetadata.new()
  porcelain
end

.convert_druid_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1677

def self.convert_druid_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Druid.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing
end

.convert_druid_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1658

def self.convert_druid_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Druid.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port_override = (plumbing.port_override)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.port = (plumbing.port)
  porcelain
end

.convert_dynamo_db_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1733

def self.convert_dynamo_db_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::DynamoDB.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.access_key = (porcelain.access_key) unless porcelain.access_key == nil
  plumbing.secret_access_key = (porcelain.secret_access_key) unless porcelain.secret_access_key == nil
  plumbing.region = (porcelain.region) unless porcelain.region == nil
  plumbing.endpoint = (porcelain.endpoint) unless porcelain.endpoint == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.role_arn = (porcelain.role_arn) unless porcelain.role_arn == nil
  plumbing.role_external_id = (porcelain.role_external_id) unless porcelain.role_external_id == nil
  plumbing
end

.convert_dynamo_db_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1712

def self.convert_dynamo_db_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = DynamoDB.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.access_key = (plumbing.access_key)
  porcelain.secret_access_key = (plumbing.secret_access_key)
  porcelain.region = (plumbing.region)
  porcelain.endpoint = (plumbing.endpoint)
  porcelain.port_override = (plumbing.port_override)
  porcelain.role_arn = (plumbing.role_arn)
  porcelain.role_external_id = (plumbing.role_external_id)
  porcelain
end

.convert_elastic_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1848

def self.convert_elastic_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Elastic.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.tls_required = (porcelain.tls_required) unless porcelain.tls_required == nil
  plumbing
end

.convert_elastic_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1828

def self.convert_elastic_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Elastic.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.tls_required = (plumbing.tls_required)
  porcelain
end

.convert_elasticache_redis_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3981

def self.convert_elasticache_redis_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::ElasticacheRedis.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.tls_required = (porcelain.tls_required) unless porcelain.tls_required == nil
  plumbing
end

.convert_elasticache_redis_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3962

def self.convert_elasticache_redis_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = ElasticacheRedis.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port_override = (plumbing.port_override)
  porcelain.password = (plumbing.password)
  porcelain.port = (plumbing.port)
  porcelain.tls_required = (plumbing.tls_required)
  porcelain
end

.convert_error_to_porcelain(err) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5706

def self.convert_error_to_porcelain(err)
  if not err.is_a? GRPC::BadStatus
    return RPCError.new(err, 2) # Unknown
  end

  if err.code == 4
    return DeadlineExceededError.new(err.message)
  end

  status = err.to_rpc_status
  if status == nil
    return RPCError.new(err.message, err.code)
  end
  case err.code
  when 3
    return BadRequestError.new(err.message)
  when 5
    return NotFoundError.new(err.message)
  when 6
    return AlreadyExistsError.new(err.message)
  when 7
    return PermissionError.new(err.message)
  when 8
    status.details.each do |detail|
      if detail.type_url == "type.googleapis.com/v1.RateLimitMetadata"
        rate_limit = detail.unpack V1::RateLimitMetadata
        return RateLimitError.new(err.message, convert_rate_limit_metadata_to_porcelain(rate_limit))
      end
    end
  when 13
    return InternalError.new(err.message)
  when 16
    return AuthenticationError.new(err.message)
  end
  return RPCError.new(err.message, err.code)
end

.convert_gateway_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4711

def self.convert_gateway_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Gateway.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.state = (porcelain.state) unless porcelain.state == nil
  plumbing.listen_address = (porcelain.listen_address) unless porcelain.listen_address == nil
  plumbing.bind_address = (porcelain.bind_address) unless porcelain.bind_address == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.gateway_filter = (porcelain.gateway_filter) unless porcelain.gateway_filter == nil
  plumbing
end

.convert_gateway_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4696

def self.convert_gateway_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Gateway.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.state = (plumbing.state)
  porcelain.listen_address = (plumbing.listen_address)
  porcelain.bind_address = (plumbing.bind_address)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.gateway_filter = (plumbing.gateway_filter)
  porcelain
end

.convert_get_response_metadata_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 136

def self.convert_get_response_metadata_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::GetResponseMetadata.new()
  plumbing
end

.convert_get_response_metadata_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 128

def self.convert_get_response_metadata_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = GetResponseMetadata.new()
  porcelain
end

.convert_google_gke_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2464

def self.convert_google_gke_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::GoogleGKE.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.endpoint = (porcelain.endpoint) unless porcelain.endpoint == nil
  plumbing.certificate_authority = (porcelain.certificate_authority) unless porcelain.certificate_authority == nil
  plumbing.service_account_key = (porcelain.service_account_key) unless porcelain.service_account_key == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_google_gke_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2446

def self.convert_google_gke_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = GoogleGKE.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.endpoint = (plumbing.endpoint)
  porcelain.certificate_authority = (plumbing.certificate_authority)
  porcelain.service_account_key = (plumbing.service_account_key)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_google_gke_user_impersonation_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2516

def self.convert_google_gke_user_impersonation_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::GoogleGKEUserImpersonation.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.endpoint = (porcelain.endpoint) unless porcelain.endpoint == nil
  plumbing.certificate_authority = (porcelain.certificate_authority) unless porcelain.certificate_authority == nil
  plumbing.service_account_key = (porcelain.service_account_key) unless porcelain.service_account_key == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_google_gke_user_impersonation_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2498

def self.convert_google_gke_user_impersonation_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = GoogleGKEUserImpersonation.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.endpoint = (plumbing.endpoint)
  porcelain.certificate_authority = (plumbing.certificate_authority)
  porcelain.service_account_key = (plumbing.service_account_key)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_greenplum_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3587

def self.convert_greenplum_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Greenplum.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.override_database = (porcelain.override_database) unless porcelain.override_database == nil
  plumbing
end

.convert_greenplum_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3566

def self.convert_greenplum_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Greenplum.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.override_database = (plumbing.override_database)
  porcelain
end

.convert_http_auth_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2016

def self.convert_http_auth_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::HTTPAuth.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.url = (porcelain.url) unless porcelain.url == nil
  plumbing.healthcheck_path = (porcelain.healthcheck_path) unless porcelain.healthcheck_path == nil
  plumbing.auth_header = (porcelain.auth_header) unless porcelain.auth_header == nil
  plumbing.headers_blacklist = (porcelain.headers_blacklist) unless porcelain.headers_blacklist == nil
  plumbing.default_path = (porcelain.default_path) unless porcelain.default_path == nil
  plumbing.subdomain = (porcelain.subdomain) unless porcelain.subdomain == nil
  plumbing
end

.convert_http_auth_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1996

def self.convert_http_auth_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = HTTPAuth.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.url = (plumbing.url)
  porcelain.healthcheck_path = (plumbing.healthcheck_path)
  porcelain.auth_header = (plumbing.auth_header)
  porcelain.headers_blacklist = (plumbing.headers_blacklist)
  porcelain.default_path = (plumbing.default_path)
  porcelain.subdomain = (plumbing.subdomain)
  porcelain
end

.convert_http_basic_auth_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1905

def self.convert_http_basic_auth_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::HTTPBasicAuth.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.url = (porcelain.url) unless porcelain.url == nil
  plumbing.healthcheck_path = (porcelain.healthcheck_path) unless porcelain.healthcheck_path == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.headers_blacklist = (porcelain.headers_blacklist) unless porcelain.headers_blacklist == nil
  plumbing.default_path = (porcelain.default_path) unless porcelain.default_path == nil
  plumbing.subdomain = (porcelain.subdomain) unless porcelain.subdomain == nil
  plumbing
end

.convert_http_basic_auth_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1884

def self.convert_http_basic_auth_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = HTTPBasicAuth.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.url = (plumbing.url)
  porcelain.healthcheck_path = (plumbing.healthcheck_path)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.headers_blacklist = (plumbing.headers_blacklist)
  porcelain.default_path = (plumbing.default_path)
  porcelain.subdomain = (plumbing.subdomain)
  porcelain
end

.convert_http_no_auth_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1961

def self.convert_http_no_auth_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::HTTPNoAuth.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.url = (porcelain.url) unless porcelain.url == nil
  plumbing.healthcheck_path = (porcelain.healthcheck_path) unless porcelain.healthcheck_path == nil
  plumbing.headers_blacklist = (porcelain.headers_blacklist) unless porcelain.headers_blacklist == nil
  plumbing.default_path = (porcelain.default_path) unless porcelain.default_path == nil
  plumbing.subdomain = (porcelain.subdomain) unless porcelain.subdomain == nil
  plumbing
end

.convert_http_no_auth_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1942

def self.convert_http_no_auth_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = HTTPNoAuth.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.url = (plumbing.url)
  porcelain.healthcheck_path = (plumbing.healthcheck_path)
  porcelain.headers_blacklist = (plumbing.headers_blacklist)
  porcelain.default_path = (plumbing.default_path)
  porcelain.subdomain = (plumbing.subdomain)
  porcelain
end

.convert_kubernetes_basic_auth_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2183

def self.convert_kubernetes_basic_auth_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::KubernetesBasicAuth.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_kubernetes_basic_auth_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2164

def self.convert_kubernetes_basic_auth_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = KubernetesBasicAuth.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port = (plumbing.port)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_kubernetes_service_account_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2236

def self.convert_kubernetes_service_account_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::KubernetesServiceAccount.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.token = (porcelain.token) unless porcelain.token == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_kubernetes_service_account_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2218

def self.convert_kubernetes_service_account_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = KubernetesServiceAccount.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port = (plumbing.port)
  porcelain.token = (plumbing.token)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_kubernetes_service_account_user_impersonation_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2288

def self.convert_kubernetes_service_account_user_impersonation_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::KubernetesServiceAccountUserImpersonation.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.token = (porcelain.token) unless porcelain.token == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_kubernetes_service_account_user_impersonation_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2270

def self.convert_kubernetes_service_account_user_impersonation_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = KubernetesServiceAccountUserImpersonation.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port = (plumbing.port)
  porcelain.token = (plumbing.token)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_kubernetes_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2072

def self.convert_kubernetes_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Kubernetes.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.certificate_authority = (porcelain.certificate_authority) unless porcelain.certificate_authority == nil
  plumbing.client_certificate = (porcelain.client_certificate) unless porcelain.client_certificate == nil
  plumbing.client_key = (porcelain.client_key) unless porcelain.client_key == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_kubernetes_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2052

def self.convert_kubernetes_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Kubernetes.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port = (plumbing.port)
  porcelain.certificate_authority = (plumbing.certificate_authority)
  porcelain.client_certificate = (plumbing.client_certificate)
  porcelain.client_key = (plumbing.client_key)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_kubernetes_user_impersonation_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2128

def self.convert_kubernetes_user_impersonation_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::KubernetesUserImpersonation.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.certificate_authority = (porcelain.certificate_authority) unless porcelain.certificate_authority == nil
  plumbing.client_certificate = (porcelain.client_certificate) unless porcelain.client_certificate == nil
  plumbing.client_key = (porcelain.client_key) unless porcelain.client_key == nil
  plumbing.healthcheck_namespace = (porcelain.healthcheck_namespace) unless porcelain.healthcheck_namespace == nil
  plumbing
end

.convert_kubernetes_user_impersonation_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2108

def self.convert_kubernetes_user_impersonation_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = KubernetesUserImpersonation.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port = (plumbing.port)
  porcelain.certificate_authority = (plumbing.certificate_authority)
  porcelain.client_certificate = (plumbing.client_certificate)
  porcelain.client_key = (plumbing.client_key)
  porcelain.healthcheck_namespace = (plumbing.healthcheck_namespace)
  porcelain
end

.convert_maria_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3300

def self.convert_maria_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Maria.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing
end

.convert_maria_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3280

def self.convert_maria_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Maria.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain
end

.convert_memcached_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2837

def self.convert_memcached_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Memcached.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing
end

.convert_memcached_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2820

def self.convert_memcached_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Memcached.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain
end

.convert_memsql_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3356

def self.convert_memsql_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Memsql.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing
end

.convert_memsql_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3336

def self.convert_memsql_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Memsql.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain
end

.convert_mongo_host_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3013

def self.convert_mongo_host_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::MongoHost.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.auth_database = (porcelain.auth_database) unless porcelain.auth_database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.tls_required = (porcelain.tls_required) unless porcelain.tls_required == nil
  plumbing
end

.convert_mongo_host_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2992

def self.convert_mongo_host_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = MongoHost.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.auth_database = (plumbing.auth_database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.port = (plumbing.port)
  porcelain.tls_required = (plumbing.tls_required)
  porcelain
end

.convert_mongo_legacy_host_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2892

def self.convert_mongo_legacy_host_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::MongoLegacyHost.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.auth_database = (porcelain.auth_database) unless porcelain.auth_database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.replica_set = (porcelain.replica_set) unless porcelain.replica_set == nil
  plumbing.tls_required = (porcelain.tls_required) unless porcelain.tls_required == nil
  plumbing
end

.convert_mongo_legacy_host_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2870

def self.convert_mongo_legacy_host_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = MongoLegacyHost.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.auth_database = (plumbing.auth_database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.port = (plumbing.port)
  porcelain.replica_set = (plumbing.replica_set)
  porcelain.tls_required = (plumbing.tls_required)
  porcelain
end

.convert_mongo_legacy_replicaset_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2953

def self.convert_mongo_legacy_replicaset_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::MongoLegacyReplicaset.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.auth_database = (porcelain.auth_database) unless porcelain.auth_database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.replica_set = (porcelain.replica_set) unless porcelain.replica_set == nil
  plumbing.connect_to_replica = (porcelain.connect_to_replica) unless porcelain.connect_to_replica == nil
  plumbing.tls_required = (porcelain.tls_required) unless porcelain.tls_required == nil
  plumbing
end

.convert_mongo_legacy_replicaset_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2930

def self.convert_mongo_legacy_replicaset_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = MongoLegacyReplicaset.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.auth_database = (plumbing.auth_database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.port = (plumbing.port)
  porcelain.replica_set = (plumbing.replica_set)
  porcelain.connect_to_replica = (plumbing.connect_to_replica)
  porcelain.tls_required = (plumbing.tls_required)
  porcelain
end

.convert_mongo_replica_set_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3073

def self.convert_mongo_replica_set_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::MongoReplicaSet.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.auth_database = (porcelain.auth_database) unless porcelain.auth_database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.replica_set = (porcelain.replica_set) unless porcelain.replica_set == nil
  plumbing.connect_to_replica = (porcelain.connect_to_replica) unless porcelain.connect_to_replica == nil
  plumbing.tls_required = (porcelain.tls_required) unless porcelain.tls_required == nil
  plumbing
end

.convert_mongo_replica_set_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3050

def self.convert_mongo_replica_set_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = MongoReplicaSet.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.auth_database = (plumbing.auth_database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.port = (plumbing.port)
  porcelain.replica_set = (plumbing.replica_set)
  porcelain.connect_to_replica = (plumbing.connect_to_replica)
  porcelain.tls_required = (plumbing.tls_required)
  porcelain
end

.convert_mysql_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3132

def self.convert_mysql_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Mysql.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing
end

.convert_mysql_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3112

def self.convert_mysql_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Mysql.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain
end

.convert_node_create_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4472

def self.convert_node_create_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::NodeCreateResponse.new()
  plumbing.meta = convert_create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.node = convert_node_to_plumbing(porcelain.node) unless porcelain.node == nil
  plumbing.token = (porcelain.token) unless porcelain.token == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_node_create_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4460

def self.convert_node_create_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = NodeCreateResponse.new()
  porcelain.meta = convert_create_response_metadata_to_porcelain(plumbing.meta)
  porcelain.node = convert_node_to_porcelain(plumbing.node)
  porcelain.token = (plumbing.token)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_node_delete_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4586

def self.convert_node_delete_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::NodeDeleteResponse.new()
  plumbing.meta = convert_delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_node_delete_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4576

def self.convert_node_delete_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = NodeDeleteResponse.new()
  porcelain.meta = convert_delete_response_metadata_to_porcelain(plumbing.meta)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_node_get_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4511

def self.convert_node_get_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::NodeGetResponse.new()
  plumbing.meta = convert_get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.node = convert_node_to_plumbing(porcelain.node) unless porcelain.node == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_node_get_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4500

def self.convert_node_get_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = NodeGetResponse.new()
  porcelain.meta = convert_get_response_metadata_to_porcelain(plumbing.meta)
  porcelain.node = convert_node_to_porcelain(plumbing.node)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_node_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4612

def self.convert_node_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Node.new()
  if porcelain.instance_of? Relay
    plumbing.relay = convert_relay_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Gateway
    plumbing.gateway = convert_gateway_to_plumbing(porcelain)
  end
  plumbing
end

.convert_node_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4626

def self.convert_node_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  if plumbing.relay != nil
    return convert_relay_to_porcelain(plumbing.relay)
  end
  if plumbing.gateway != nil
    return convert_gateway_to_porcelain(plumbing.gateway)
  end
end

.convert_node_update_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4549

def self.convert_node_update_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::NodeUpdateResponse.new()
  plumbing.meta = convert_update_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.node = convert_node_to_plumbing(porcelain.node) unless porcelain.node == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_node_update_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4538

def self.convert_node_update_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = NodeUpdateResponse.new()
  porcelain.meta = convert_update_response_metadata_to_porcelain(plumbing.meta)
  porcelain.node = convert_node_to_porcelain(plumbing.node)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_oracle_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3413

def self.convert_oracle_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Oracle.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.tls_required = (porcelain.tls_required) unless porcelain.tls_required == nil
  plumbing
end

.convert_oracle_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3392

def self.convert_oracle_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Oracle.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port = (plumbing.port)
  porcelain.port_override = (plumbing.port_override)
  porcelain.tls_required = (plumbing.tls_required)
  porcelain
end

.convert_postgres_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3471

def self.convert_postgres_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Postgres.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.override_database = (porcelain.override_database) unless porcelain.override_database == nil
  plumbing
end

.convert_postgres_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3450

def self.convert_postgres_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Postgres.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.override_database = (plumbing.override_database)
  porcelain
end

.convert_presto_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3819

def self.convert_presto_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Presto.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.tls_required = (porcelain.tls_required) unless porcelain.tls_required == nil
  plumbing
end

.convert_presto_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3798

def self.convert_presto_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Presto.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.username = (plumbing.username)
  porcelain.tls_required = (plumbing.tls_required)
  porcelain
end

.convert_rate_limit_metadata_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 236

def self.convert_rate_limit_metadata_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RateLimitMetadata.new()
  plumbing.limit = (porcelain.limit) unless porcelain.limit == nil
  plumbing.remaining = (porcelain.remaining) unless porcelain.remaining == nil
  plumbing.reset_at = convert_timestamp_to_plumbing(porcelain.reset_at) unless porcelain.reset_at == nil
  plumbing.bucket = (porcelain.bucket) unless porcelain.bucket == nil
  plumbing
end

.convert_rate_limit_metadata_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 224

def self.convert_rate_limit_metadata_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RateLimitMetadata.new()
  porcelain.limit = (plumbing.limit)
  porcelain.remaining = (plumbing.remaining)
  porcelain.reset_at = convert_timestamp_to_porcelain(plumbing.reset_at)
  porcelain.bucket = (plumbing.bucket)
  porcelain
end

.convert_rdp_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3875

def self.convert_rdp_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RDP.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing
end

.convert_rdp_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3856

def self.convert_rdp_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RDP.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain
end

.convert_redis_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3928

def self.convert_redis_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Redis.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing
end

.convert_redis_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3910

def self.convert_redis_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Redis.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.port_override = (plumbing.port_override)
  porcelain.password = (plumbing.password)
  porcelain.port = (plumbing.port)
  porcelain
end

.convert_redshift_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3703

def self.convert_redshift_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Redshift.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.override_database = (porcelain.override_database) unless porcelain.override_database == nil
  plumbing
end

.convert_redshift_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3682

def self.convert_redshift_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Redshift.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.override_database = (plumbing.override_database)
  porcelain
end

.convert_relay_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4667

def self.convert_relay_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Relay.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.state = (porcelain.state) unless porcelain.state == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.gateway_filter = (porcelain.gateway_filter) unless porcelain.gateway_filter == nil
  plumbing
end

.convert_relay_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4654

def self.convert_relay_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Relay.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.state = (plumbing.state)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.gateway_filter = (plumbing.gateway_filter)
  porcelain
end

.convert_repeated_account_attachment_create_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 321

def self.convert_repeated_account_attachment_create_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_attachment_create_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_attachment_create_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 330

def self.convert_repeated_account_attachment_create_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_attachment_create_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_attachment_delete_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 395

def self.convert_repeated_account_attachment_delete_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_attachment_delete_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_attachment_delete_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 404

def self.convert_repeated_account_attachment_delete_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_attachment_delete_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_attachment_get_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 359

def self.convert_repeated_account_attachment_get_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_attachment_get_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_attachment_get_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 368

def self.convert_repeated_account_attachment_get_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_attachment_get_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_attachment_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 433

def self.convert_repeated_account_attachment_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_attachment_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_attachment_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 442

def self.convert_repeated_account_attachment_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_attachment_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_create_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 627

def self.convert_repeated_account_create_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_create_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_create_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 636

def self.convert_repeated_account_create_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_create_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_delete_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 739

def self.convert_repeated_account_delete_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_delete_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_delete_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 748

def self.convert_repeated_account_delete_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_delete_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_get_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 665

def self.convert_repeated_account_get_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_get_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_get_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 674

def self.convert_repeated_account_get_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_get_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_grant_create_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 471

def self.convert_repeated_account_grant_create_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_grant_create_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_grant_create_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 480

def self.convert_repeated_account_grant_create_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_grant_create_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_grant_delete_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 545

def self.convert_repeated_account_grant_delete_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_grant_delete_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_grant_delete_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 554

def self.convert_repeated_account_grant_delete_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_grant_delete_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_grant_get_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 509

def self.convert_repeated_account_grant_get_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_grant_get_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_grant_get_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 518

def self.convert_repeated_account_grant_get_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_grant_get_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_grant_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 587

def self.convert_repeated_account_grant_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_grant_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_grant_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 596

def self.convert_repeated_account_grant_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_grant_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 781

def self.convert_repeated_account_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 790

def self.convert_repeated_account_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_account_update_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 703

def self.convert_repeated_account_update_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_account_update_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_account_update_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 712

def self.convert_repeated_account_update_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_account_update_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_aks_basic_auth_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2699

def self.convert_repeated_aks_basic_auth_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_aks_basic_auth_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_aks_basic_auth_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2708

def self.convert_repeated_aks_basic_auth_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_aks_basic_auth_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_aks_service_account_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2751

def self.convert_repeated_aks_service_account_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_aks_service_account_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_aks_service_account_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2760

def self.convert_repeated_aks_service_account_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_aks_service_account_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_aks_service_account_user_impersonation_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2803

def self.convert_repeated_aks_service_account_user_impersonation_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_aks_service_account_user_impersonation_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_aks_service_account_user_impersonation_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2812

def self.convert_repeated_aks_service_account_user_impersonation_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_aks_service_account_user_impersonation_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_aks_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2589

def self.convert_repeated_aks_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_aks_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_aks_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2598

def self.convert_repeated_aks_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_aks_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_aks_user_impersonation_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2645

def self.convert_repeated_aks_user_impersonation_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_aks_user_impersonation_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_aks_user_impersonation_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2654

def self.convert_repeated_aks_user_impersonation_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_aks_user_impersonation_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_amazon_eks_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2367

def self.convert_repeated_amazon_eks_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_amazon_eks_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_amazon_eks_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2376

def self.convert_repeated_amazon_eks_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_amazon_eks_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_amazon_eks_user_impersonation_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2429

def self.convert_repeated_amazon_eks_user_impersonation_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_amazon_eks_user_impersonation_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_amazon_eks_user_impersonation_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2438

def self.convert_repeated_amazon_eks_user_impersonation_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_amazon_eks_user_impersonation_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_amazon_es_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1811

def self.convert_repeated_amazon_es_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_amazon_es_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_amazon_es_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1820

def self.convert_repeated_amazon_es_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_amazon_es_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_athena_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1365

def self.convert_repeated_athena_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_athena_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_athena_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1374

def self.convert_repeated_athena_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_athena_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_aurora_mysql_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3207

def self.convert_repeated_aurora_mysql_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_aurora_mysql_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_aurora_mysql_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3216

def self.convert_repeated_aurora_mysql_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_aurora_mysql_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_aurora_postgres_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3549

def self.convert_repeated_aurora_postgres_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_aurora_postgres_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_aurora_postgres_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3558

def self.convert_repeated_aurora_postgres_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_aurora_postgres_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_aws_store_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5453

def self.convert_repeated_aws_store_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_aws_store_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_aws_store_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5462

def self.convert_repeated_aws_store_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_aws_store_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_aws_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1419

def self.convert_repeated_aws_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_aws_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_aws_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1428

def self.convert_repeated_aws_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_aws_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_big_query_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1473

def self.convert_repeated_big_query_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_big_query_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_big_query_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1482

def self.convert_repeated_big_query_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_big_query_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_cassandra_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1529

def self.convert_repeated_cassandra_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_cassandra_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_cassandra_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1538

def self.convert_repeated_cassandra_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_cassandra_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_citus_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3781

def self.convert_repeated_citus_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_citus_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_citus_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3790

def self.convert_repeated_citus_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_citus_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_clustrix_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3263

def self.convert_repeated_clustrix_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_clustrix_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_clustrix_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3272

def self.convert_repeated_clustrix_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_clustrix_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_cockroach_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3665

def self.convert_repeated_cockroach_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_cockroach_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_cockroach_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3674

def self.convert_repeated_cockroach_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_cockroach_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_control_panel_get_sshca_public_key_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 903

def self.convert_repeated_control_panel_get_sshca_public_key_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_control_panel_get_sshca_public_key_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_control_panel_get_sshca_public_key_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 912

def self.convert_repeated_control_panel_get_sshca_public_key_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_control_panel_get_sshca_public_key_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_control_panel_verify_jwt_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 941

def self.convert_repeated_control_panel_verify_jwt_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_control_panel_verify_jwt_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_control_panel_verify_jwt_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 950

def self.convert_repeated_control_panel_verify_jwt_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_control_panel_verify_jwt_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_create_response_metadata_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 111

def self.convert_repeated_create_response_metadata_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_create_response_metadata_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_create_response_metadata_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 120

def self.convert_repeated_create_response_metadata_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_create_response_metadata_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_db_2_i_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1585

def self.convert_repeated_db_2_i_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_db_2_i_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_db_2_i_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1594

def self.convert_repeated_db_2_i_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_db_2_i_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_db_2_luw_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1641

def self.convert_repeated_db_2_luw_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_db_2_luw_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_db_2_luw_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1650

def self.convert_repeated_db_2_luw_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_db_2_luw_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_delete_response_metadata_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 207

def self.convert_repeated_delete_response_metadata_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_delete_response_metadata_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_delete_response_metadata_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 216

def self.convert_repeated_delete_response_metadata_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_delete_response_metadata_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_druid_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1695

def self.convert_repeated_druid_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_druid_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_druid_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1704

def self.convert_repeated_druid_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_druid_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_dynamo_db_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1753

def self.convert_repeated_dynamo_db_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_dynamo_db_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_dynamo_db_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1762

def self.convert_repeated_dynamo_db_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_dynamo_db_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_elastic_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1867

def self.convert_repeated_elastic_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_elastic_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_elastic_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1876

def self.convert_repeated_elastic_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_elastic_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_elasticache_redis_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3999

def self.convert_repeated_elasticache_redis_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_elasticache_redis_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_elasticache_redis_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4008

def self.convert_repeated_elasticache_redis_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_elasticache_redis_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_gateway_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4725

def self.convert_repeated_gateway_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_gateway_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_gateway_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4734

def self.convert_repeated_gateway_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_gateway_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_get_response_metadata_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 143

def self.convert_repeated_get_response_metadata_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_get_response_metadata_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_get_response_metadata_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 152

def self.convert_repeated_get_response_metadata_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_get_response_metadata_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_google_gke_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2481

def self.convert_repeated_google_gke_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_google_gke_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_google_gke_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2490

def self.convert_repeated_google_gke_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_google_gke_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_google_gke_user_impersonation_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2533

def self.convert_repeated_google_gke_user_impersonation_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_google_gke_user_impersonation_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_google_gke_user_impersonation_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2542

def self.convert_repeated_google_gke_user_impersonation_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_google_gke_user_impersonation_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_greenplum_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3607

def self.convert_repeated_greenplum_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_greenplum_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_greenplum_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3616

def self.convert_repeated_greenplum_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_greenplum_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_http_auth_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2035

def self.convert_repeated_http_auth_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_http_auth_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_http_auth_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2044

def self.convert_repeated_http_auth_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_http_auth_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_http_basic_auth_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1925

def self.convert_repeated_http_basic_auth_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_http_basic_auth_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_http_basic_auth_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1934

def self.convert_repeated_http_basic_auth_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_http_basic_auth_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_http_no_auth_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1979

def self.convert_repeated_http_no_auth_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_http_no_auth_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_http_no_auth_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1988

def self.convert_repeated_http_no_auth_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_http_no_auth_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_kubernetes_basic_auth_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2201

def self.convert_repeated_kubernetes_basic_auth_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_kubernetes_basic_auth_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_kubernetes_basic_auth_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2210

def self.convert_repeated_kubernetes_basic_auth_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_kubernetes_basic_auth_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_kubernetes_service_account_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2253

def self.convert_repeated_kubernetes_service_account_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_kubernetes_service_account_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_kubernetes_service_account_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2262

def self.convert_repeated_kubernetes_service_account_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_kubernetes_service_account_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_kubernetes_service_account_user_impersonation_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2305

def self.convert_repeated_kubernetes_service_account_user_impersonation_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_kubernetes_service_account_user_impersonation_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_kubernetes_service_account_user_impersonation_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2314

def self.convert_repeated_kubernetes_service_account_user_impersonation_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_kubernetes_service_account_user_impersonation_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_kubernetes_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2091

def self.convert_repeated_kubernetes_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_kubernetes_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_kubernetes_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2100

def self.convert_repeated_kubernetes_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_kubernetes_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_kubernetes_user_impersonation_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2147

def self.convert_repeated_kubernetes_user_impersonation_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_kubernetes_user_impersonation_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_kubernetes_user_impersonation_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2156

def self.convert_repeated_kubernetes_user_impersonation_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_kubernetes_user_impersonation_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_maria_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3319

def self.convert_repeated_maria_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_maria_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_maria_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3328

def self.convert_repeated_maria_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_maria_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_memcached_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2853

def self.convert_repeated_memcached_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_memcached_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_memcached_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2862

def self.convert_repeated_memcached_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_memcached_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_memsql_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3375

def self.convert_repeated_memsql_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_memsql_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_memsql_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3384

def self.convert_repeated_memsql_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_memsql_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_mongo_host_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3033

def self.convert_repeated_mongo_host_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_mongo_host_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_mongo_host_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3042

def self.convert_repeated_mongo_host_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_mongo_host_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_mongo_legacy_host_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2913

def self.convert_repeated_mongo_legacy_host_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_mongo_legacy_host_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_mongo_legacy_host_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2922

def self.convert_repeated_mongo_legacy_host_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_mongo_legacy_host_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_mongo_legacy_replicaset_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2975

def self.convert_repeated_mongo_legacy_replicaset_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_mongo_legacy_replicaset_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_mongo_legacy_replicaset_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 2984

def self.convert_repeated_mongo_legacy_replicaset_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_mongo_legacy_replicaset_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_mongo_replica_set_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3095

def self.convert_repeated_mongo_replica_set_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_mongo_replica_set_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_mongo_replica_set_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3104

def self.convert_repeated_mongo_replica_set_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_mongo_replica_set_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_mysql_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3151

def self.convert_repeated_mysql_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_mysql_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_mysql_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3160

def self.convert_repeated_mysql_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_mysql_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_node_create_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4483

def self.convert_repeated_node_create_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_node_create_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_node_create_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4492

def self.convert_repeated_node_create_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_node_create_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_node_delete_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4595

def self.convert_repeated_node_delete_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_node_delete_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_node_delete_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4604

def self.convert_repeated_node_delete_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_node_delete_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_node_get_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4521

def self.convert_repeated_node_get_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_node_get_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_node_get_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4530

def self.convert_repeated_node_get_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_node_get_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_node_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4637

def self.convert_repeated_node_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_node_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_node_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4646

def self.convert_repeated_node_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_node_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_node_update_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4559

def self.convert_repeated_node_update_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_node_update_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_node_update_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4568

def self.convert_repeated_node_update_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_node_update_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_oracle_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3433

def self.convert_repeated_oracle_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_oracle_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_oracle_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3442

def self.convert_repeated_oracle_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_oracle_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_postgres_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3491

def self.convert_repeated_postgres_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_postgres_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_postgres_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3500

def self.convert_repeated_postgres_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_postgres_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_presto_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3839

def self.convert_repeated_presto_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_presto_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_presto_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3848

def self.convert_repeated_presto_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_presto_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_rate_limit_metadata_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 247

def self.convert_repeated_rate_limit_metadata_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_rate_limit_metadata_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_rate_limit_metadata_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 256

def self.convert_repeated_rate_limit_metadata_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_rate_limit_metadata_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_rdp_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3893

def self.convert_repeated_rdp_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_rdp_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_rdp_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3902

def self.convert_repeated_rdp_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_rdp_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_redis_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3945

def self.convert_repeated_redis_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_redis_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_redis_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3954

def self.convert_repeated_redis_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_redis_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_redshift_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3723

def self.convert_repeated_redshift_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_redshift_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_redshift_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 3732

def self.convert_repeated_redshift_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_redshift_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_relay_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4679

def self.convert_repeated_relay_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_relay_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_relay_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4688

def self.convert_repeated_relay_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_relay_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_resource_create_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4763

def self.convert_repeated_resource_create_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_resource_create_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_resource_create_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4772

def self.convert_repeated_resource_create_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_resource_create_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_resource_delete_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4875

def self.convert_repeated_resource_delete_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_resource_delete_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_resource_delete_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4884

def self.convert_repeated_resource_delete_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_resource_delete_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_resource_get_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4801

def self.convert_repeated_resource_get_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_resource_get_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_resource_get_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4810

def self.convert_repeated_resource_get_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_resource_get_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_resource_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1307

def self.convert_repeated_resource_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_resource_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_resource_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1316

def self.convert_repeated_resource_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_resource_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_resource_update_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4839

def self.convert_repeated_resource_update_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_resource_update_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_resource_update_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4848

def self.convert_repeated_resource_update_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_resource_update_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_attachment_create_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4913

def self.convert_repeated_role_attachment_create_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_attachment_create_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_attachment_create_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4922

def self.convert_repeated_role_attachment_create_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_attachment_create_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_attachment_delete_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4987

def self.convert_repeated_role_attachment_delete_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_attachment_delete_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_attachment_delete_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4996

def self.convert_repeated_role_attachment_delete_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_attachment_delete_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_attachment_get_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4951

def self.convert_repeated_role_attachment_get_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_attachment_get_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_attachment_get_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4960

def self.convert_repeated_role_attachment_get_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_attachment_get_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_attachment_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5025

def self.convert_repeated_role_attachment_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_attachment_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_attachment_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5034

def self.convert_repeated_role_attachment_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_attachment_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_create_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5213

def self.convert_repeated_role_create_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_create_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_create_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5222

def self.convert_repeated_role_create_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_create_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_delete_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5325

def self.convert_repeated_role_delete_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_delete_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_delete_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5334

def self.convert_repeated_role_delete_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_delete_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_get_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5251

def self.convert_repeated_role_get_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_get_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_get_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5260

def self.convert_repeated_role_get_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_get_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_grant_create_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5063

def self.convert_repeated_role_grant_create_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_grant_create_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_grant_create_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5072

def self.convert_repeated_role_grant_create_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_grant_create_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_grant_delete_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5137

def self.convert_repeated_role_grant_delete_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_grant_delete_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_grant_delete_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5146

def self.convert_repeated_role_grant_delete_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_grant_delete_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_grant_get_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5101

def self.convert_repeated_role_grant_get_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_grant_get_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_grant_get_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5110

def self.convert_repeated_role_grant_get_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_grant_get_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_grant_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5175

def self.convert_repeated_role_grant_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_grant_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_grant_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5184

def self.convert_repeated_role_grant_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_grant_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5365

def self.convert_repeated_role_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5374

def self.convert_repeated_role_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_role_update_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5289

def self.convert_repeated_role_update_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_role_update_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_role_update_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5298

def self.convert_repeated_role_update_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_role_update_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_secret_store_create_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5577

def self.convert_repeated_secret_store_create_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_secret_store_create_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_secret_store_create_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5586

def self.convert_repeated_secret_store_create_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_secret_store_create_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_secret_store_delete_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5689

def self.convert_repeated_secret_store_delete_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_secret_store_delete_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_secret_store_delete_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5698

def self.convert_repeated_secret_store_delete_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_secret_store_delete_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_secret_store_get_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5615

def self.convert_repeated_secret_store_get_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_secret_store_get_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_secret_store_get_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5624

def self.convert_repeated_secret_store_get_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_secret_store_get_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_secret_store_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5413

def self.convert_repeated_secret_store_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_secret_store_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_secret_store_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5422

def self.convert_repeated_secret_store_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_secret_store_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_secret_store_update_response_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5653

def self.convert_repeated_secret_store_update_response_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_secret_store_update_response_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_secret_store_update_response_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5662

def self.convert_repeated_secret_store_update_response_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_secret_store_update_response_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_service_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 865

def self.convert_repeated_service_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_service_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_service_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 874

def self.convert_repeated_service_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_service_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_snowflake_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4055

def self.convert_repeated_snowflake_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_snowflake_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_snowflake_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4064

def self.convert_repeated_snowflake_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_snowflake_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_sql_server_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4115

def self.convert_repeated_sql_server_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_sql_server_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_sql_server_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4124

def self.convert_repeated_sql_server_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_sql_server_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_ssh_cert_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4225

def self.convert_repeated_ssh_cert_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_ssh_cert_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_ssh_cert_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4234

def self.convert_repeated_ssh_cert_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_ssh_cert_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_ssh_customer_key_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4281

def self.convert_repeated_ssh_customer_key_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_ssh_customer_key_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_ssh_customer_key_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4290

def self.convert_repeated_ssh_customer_key_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_ssh_customer_key_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_ssh_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4171

def self.convert_repeated_ssh_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_ssh_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_ssh_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4180

def self.convert_repeated_ssh_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_ssh_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_sybase_iq_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4389

def self.convert_repeated_sybase_iq_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_sybase_iq_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_sybase_iq_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4398

def self.convert_repeated_sybase_iq_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_sybase_iq_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_sybase_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4335

def self.convert_repeated_sybase_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_sybase_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_sybase_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4344

def self.convert_repeated_sybase_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_sybase_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_tag_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 283

def self.convert_repeated_tag_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_tag_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_tag_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 292

def self.convert_repeated_tag_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_tag_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_teradata_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4443

def self.convert_repeated_teradata_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_teradata_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_teradata_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4452

def self.convert_repeated_teradata_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_teradata_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_update_response_metadata_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 175

def self.convert_repeated_update_response_metadata_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_update_response_metadata_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_update_response_metadata_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 184

def self.convert_repeated_update_response_metadata_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_update_response_metadata_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_user_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 825

def self.convert_repeated_user_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_user_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_user_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 834

def self.convert_repeated_user_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_user_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_vault_tls_store_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5499

def self.convert_repeated_vault_tls_store_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_vault_tls_store_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_vault_tls_store_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5508

def self.convert_repeated_vault_tls_store_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_vault_tls_store_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_repeated_vault_token_store_to_plumbing(porcelains) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5539

def self.convert_repeated_vault_token_store_to_plumbing(porcelains)
  items = Array.new
  porcelains.each do |porcelain|
    plumbing = convert_vault_token_store_to_plumbing(porcelain)
    items.append(plumbing)
  end
  items
end

.convert_repeated_vault_token_store_to_porcelain(plumbings) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5548

def self.convert_repeated_vault_token_store_to_porcelain(plumbings)
  items = Array.new
  plumbings.each do |plumbing|
    porcelain = convert_vault_token_store_to_porcelain(plumbing)
    items.append(porcelain)
  end
  items
end

.convert_resource_create_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4753

def self.convert_resource_create_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::ResourceCreateResponse.new()
  plumbing.meta = convert_create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.resource = convert_resource_to_plumbing(porcelain.resource) unless porcelain.resource == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_resource_create_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4742

def self.convert_resource_create_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = ResourceCreateResponse.new()
  porcelain.meta = convert_create_response_metadata_to_porcelain(plumbing.meta)
  porcelain.resource = convert_resource_to_porcelain(plumbing.resource)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_resource_delete_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4866

def self.convert_resource_delete_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::ResourceDeleteResponse.new()
  plumbing.meta = convert_delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_resource_delete_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4856

def self.convert_resource_delete_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = ResourceDeleteResponse.new()
  porcelain.meta = convert_delete_response_metadata_to_porcelain(plumbing.meta)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_resource_get_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4791

def self.convert_resource_get_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::ResourceGetResponse.new()
  plumbing.meta = convert_get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.resource = convert_resource_to_plumbing(porcelain.resource) unless porcelain.resource == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_resource_get_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4780

def self.convert_resource_get_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = ResourceGetResponse.new()
  porcelain.meta = convert_get_response_metadata_to_porcelain(plumbing.meta)
  porcelain.resource = convert_resource_to_porcelain(plumbing.resource)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_resource_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 958

def self.convert_resource_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Resource.new()
  if porcelain.instance_of? Athena
    plumbing.athena = convert_athena_to_plumbing(porcelain)
  end
  if porcelain.instance_of? AWS
    plumbing.aws = convert_aws_to_plumbing(porcelain)
  end
  if porcelain.instance_of? BigQuery
    plumbing.big_query = convert_big_query_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Cassandra
    plumbing.cassandra = convert_cassandra_to_plumbing(porcelain)
  end
  if porcelain.instance_of? DB2I
    plumbing.db_2_i = convert_db_2_i_to_plumbing(porcelain)
  end
  if porcelain.instance_of? DB2LUW
    plumbing.db_2_luw = convert_db_2_luw_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Druid
    plumbing.druid = convert_druid_to_plumbing(porcelain)
  end
  if porcelain.instance_of? DynamoDB
    plumbing.dynamo_db = convert_dynamo_db_to_plumbing(porcelain)
  end
  if porcelain.instance_of? AmazonES
    plumbing.amazon_es = convert_amazon_es_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Elastic
    plumbing.elastic = convert_elastic_to_plumbing(porcelain)
  end
  if porcelain.instance_of? HTTPBasicAuth
    plumbing.http_basic_auth = convert_http_basic_auth_to_plumbing(porcelain)
  end
  if porcelain.instance_of? HTTPNoAuth
    plumbing.http_no_auth = convert_http_no_auth_to_plumbing(porcelain)
  end
  if porcelain.instance_of? HTTPAuth
    plumbing.http_auth = convert_http_auth_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Kubernetes
    plumbing.kubernetes = convert_kubernetes_to_plumbing(porcelain)
  end
  if porcelain.instance_of? KubernetesUserImpersonation
    plumbing.kubernetes_user_impersonation = convert_kubernetes_user_impersonation_to_plumbing(porcelain)
  end
  if porcelain.instance_of? KubernetesBasicAuth
    plumbing.kubernetes_basic_auth = convert_kubernetes_basic_auth_to_plumbing(porcelain)
  end
  if porcelain.instance_of? KubernetesServiceAccount
    plumbing.kubernetes_service_account = convert_kubernetes_service_account_to_plumbing(porcelain)
  end
  if porcelain.instance_of? KubernetesServiceAccountUserImpersonation
    plumbing.kubernetes_service_account_user_impersonation = convert_kubernetes_service_account_user_impersonation_to_plumbing(porcelain)
  end
  if porcelain.instance_of? AmazonEKS
    plumbing.amazon_eks = convert_amazon_eks_to_plumbing(porcelain)
  end
  if porcelain.instance_of? AmazonEKSUserImpersonation
    plumbing.amazon_eks_user_impersonation = convert_amazon_eks_user_impersonation_to_plumbing(porcelain)
  end
  if porcelain.instance_of? GoogleGKE
    plumbing.google_gke = convert_google_gke_to_plumbing(porcelain)
  end
  if porcelain.instance_of? GoogleGKEUserImpersonation
    plumbing.google_gke_user_impersonation = convert_google_gke_user_impersonation_to_plumbing(porcelain)
  end
  if porcelain.instance_of? AKS
    plumbing.aks = convert_aks_to_plumbing(porcelain)
  end
  if porcelain.instance_of? AKSUserImpersonation
    plumbing.aks_user_impersonation = convert_aks_user_impersonation_to_plumbing(porcelain)
  end
  if porcelain.instance_of? AKSBasicAuth
    plumbing.aks_basic_auth = convert_aks_basic_auth_to_plumbing(porcelain)
  end
  if porcelain.instance_of? AKSServiceAccount
    plumbing.aks_service_account = convert_aks_service_account_to_plumbing(porcelain)
  end
  if porcelain.instance_of? AKSServiceAccountUserImpersonation
    plumbing.aks_service_account_user_impersonation = convert_aks_service_account_user_impersonation_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Memcached
    plumbing.memcached = convert_memcached_to_plumbing(porcelain)
  end
  if porcelain.instance_of? MongoLegacyHost
    plumbing.mongo_legacy_host = convert_mongo_legacy_host_to_plumbing(porcelain)
  end
  if porcelain.instance_of? MongoLegacyReplicaset
    plumbing.mongo_legacy_replicaset = convert_mongo_legacy_replicaset_to_plumbing(porcelain)
  end
  if porcelain.instance_of? MongoHost
    plumbing.mongo_host = convert_mongo_host_to_plumbing(porcelain)
  end
  if porcelain.instance_of? MongoReplicaSet
    plumbing.mongo_replica_set = convert_mongo_replica_set_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Mysql
    plumbing.mysql = convert_mysql_to_plumbing(porcelain)
  end
  if porcelain.instance_of? AuroraMysql
    plumbing.aurora_mysql = convert_aurora_mysql_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Clustrix
    plumbing.clustrix = convert_clustrix_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Maria
    plumbing.maria = convert_maria_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Memsql
    plumbing.memsql = convert_memsql_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Oracle
    plumbing.oracle = convert_oracle_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Postgres
    plumbing.postgres = convert_postgres_to_plumbing(porcelain)
  end
  if porcelain.instance_of? AuroraPostgres
    plumbing.aurora_postgres = convert_aurora_postgres_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Greenplum
    plumbing.greenplum = convert_greenplum_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Cockroach
    plumbing.cockroach = convert_cockroach_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Redshift
    plumbing.redshift = convert_redshift_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Citus
    plumbing.citus = convert_citus_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Presto
    plumbing.presto = convert_presto_to_plumbing(porcelain)
  end
  if porcelain.instance_of? RDP
    plumbing.rdp = convert_rdp_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Redis
    plumbing.redis = convert_redis_to_plumbing(porcelain)
  end
  if porcelain.instance_of? ElasticacheRedis
    plumbing.elasticache_redis = convert_elasticache_redis_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Snowflake
    plumbing.snowflake = convert_snowflake_to_plumbing(porcelain)
  end
  if porcelain.instance_of? SQLServer
    plumbing.sql_server = convert_sql_server_to_plumbing(porcelain)
  end
  if porcelain.instance_of? SSH
    plumbing.ssh = convert_ssh_to_plumbing(porcelain)
  end
  if porcelain.instance_of? SSHCert
    plumbing.ssh_cert = convert_ssh_cert_to_plumbing(porcelain)
  end
  if porcelain.instance_of? SSHCustomerKey
    plumbing.ssh_customer_key = convert_ssh_customer_key_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Sybase
    plumbing.sybase = convert_sybase_to_plumbing(porcelain)
  end
  if porcelain.instance_of? SybaseIQ
    plumbing.sybase_iq = convert_sybase_iq_to_plumbing(porcelain)
  end
  if porcelain.instance_of? Teradata
    plumbing.teradata = convert_teradata_to_plumbing(porcelain)
  end
  plumbing
end

.convert_resource_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 1134

def self.convert_resource_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  if plumbing.athena != nil
    return convert_athena_to_porcelain(plumbing.athena)
  end
  if plumbing.aws != nil
    return convert_aws_to_porcelain(plumbing.aws)
  end
  if plumbing.big_query != nil
    return convert_big_query_to_porcelain(plumbing.big_query)
  end
  if plumbing.cassandra != nil
    return convert_cassandra_to_porcelain(plumbing.cassandra)
  end
  if plumbing.db_2_i != nil
    return convert_db_2_i_to_porcelain(plumbing.db_2_i)
  end
  if plumbing.db_2_luw != nil
    return convert_db_2_luw_to_porcelain(plumbing.db_2_luw)
  end
  if plumbing.druid != nil
    return convert_druid_to_porcelain(plumbing.druid)
  end
  if plumbing.dynamo_db != nil
    return convert_dynamo_db_to_porcelain(plumbing.dynamo_db)
  end
  if plumbing.amazon_es != nil
    return convert_amazon_es_to_porcelain(plumbing.amazon_es)
  end
  if plumbing.elastic != nil
    return convert_elastic_to_porcelain(plumbing.elastic)
  end
  if plumbing.http_basic_auth != nil
    return convert_http_basic_auth_to_porcelain(plumbing.http_basic_auth)
  end
  if plumbing.http_no_auth != nil
    return convert_http_no_auth_to_porcelain(plumbing.http_no_auth)
  end
  if plumbing.http_auth != nil
    return convert_http_auth_to_porcelain(plumbing.http_auth)
  end
  if plumbing.kubernetes != nil
    return convert_kubernetes_to_porcelain(plumbing.kubernetes)
  end
  if plumbing.kubernetes_user_impersonation != nil
    return convert_kubernetes_user_impersonation_to_porcelain(plumbing.kubernetes_user_impersonation)
  end
  if plumbing.kubernetes_basic_auth != nil
    return convert_kubernetes_basic_auth_to_porcelain(plumbing.kubernetes_basic_auth)
  end
  if plumbing.kubernetes_service_account != nil
    return convert_kubernetes_service_account_to_porcelain(plumbing.kubernetes_service_account)
  end
  if plumbing.kubernetes_service_account_user_impersonation != nil
    return convert_kubernetes_service_account_user_impersonation_to_porcelain(plumbing.kubernetes_service_account_user_impersonation)
  end
  if plumbing.amazon_eks != nil
    return convert_amazon_eks_to_porcelain(plumbing.amazon_eks)
  end
  if plumbing.amazon_eks_user_impersonation != nil
    return convert_amazon_eks_user_impersonation_to_porcelain(plumbing.amazon_eks_user_impersonation)
  end
  if plumbing.google_gke != nil
    return convert_google_gke_to_porcelain(plumbing.google_gke)
  end
  if plumbing.google_gke_user_impersonation != nil
    return convert_google_gke_user_impersonation_to_porcelain(plumbing.google_gke_user_impersonation)
  end
  if plumbing.aks != nil
    return convert_aks_to_porcelain(plumbing.aks)
  end
  if plumbing.aks_user_impersonation != nil
    return convert_aks_user_impersonation_to_porcelain(plumbing.aks_user_impersonation)
  end
  if plumbing.aks_basic_auth != nil
    return convert_aks_basic_auth_to_porcelain(plumbing.aks_basic_auth)
  end
  if plumbing.aks_service_account != nil
    return convert_aks_service_account_to_porcelain(plumbing.aks_service_account)
  end
  if plumbing.aks_service_account_user_impersonation != nil
    return convert_aks_service_account_user_impersonation_to_porcelain(plumbing.aks_service_account_user_impersonation)
  end
  if plumbing.memcached != nil
    return convert_memcached_to_porcelain(plumbing.memcached)
  end
  if plumbing.mongo_legacy_host != nil
    return convert_mongo_legacy_host_to_porcelain(plumbing.mongo_legacy_host)
  end
  if plumbing.mongo_legacy_replicaset != nil
    return convert_mongo_legacy_replicaset_to_porcelain(plumbing.mongo_legacy_replicaset)
  end
  if plumbing.mongo_host != nil
    return convert_mongo_host_to_porcelain(plumbing.mongo_host)
  end
  if plumbing.mongo_replica_set != nil
    return convert_mongo_replica_set_to_porcelain(plumbing.mongo_replica_set)
  end
  if plumbing.mysql != nil
    return convert_mysql_to_porcelain(plumbing.mysql)
  end
  if plumbing.aurora_mysql != nil
    return convert_aurora_mysql_to_porcelain(plumbing.aurora_mysql)
  end
  if plumbing.clustrix != nil
    return convert_clustrix_to_porcelain(plumbing.clustrix)
  end
  if plumbing.maria != nil
    return convert_maria_to_porcelain(plumbing.maria)
  end
  if plumbing.memsql != nil
    return convert_memsql_to_porcelain(plumbing.memsql)
  end
  if plumbing.oracle != nil
    return convert_oracle_to_porcelain(plumbing.oracle)
  end
  if plumbing.postgres != nil
    return convert_postgres_to_porcelain(plumbing.postgres)
  end
  if plumbing.aurora_postgres != nil
    return convert_aurora_postgres_to_porcelain(plumbing.aurora_postgres)
  end
  if plumbing.greenplum != nil
    return convert_greenplum_to_porcelain(plumbing.greenplum)
  end
  if plumbing.cockroach != nil
    return convert_cockroach_to_porcelain(plumbing.cockroach)
  end
  if plumbing.redshift != nil
    return convert_redshift_to_porcelain(plumbing.redshift)
  end
  if plumbing.citus != nil
    return convert_citus_to_porcelain(plumbing.citus)
  end
  if plumbing.presto != nil
    return convert_presto_to_porcelain(plumbing.presto)
  end
  if plumbing.rdp != nil
    return convert_rdp_to_porcelain(plumbing.rdp)
  end
  if plumbing.redis != nil
    return convert_redis_to_porcelain(plumbing.redis)
  end
  if plumbing.elasticache_redis != nil
    return convert_elasticache_redis_to_porcelain(plumbing.elasticache_redis)
  end
  if plumbing.snowflake != nil
    return convert_snowflake_to_porcelain(plumbing.snowflake)
  end
  if plumbing.sql_server != nil
    return convert_sql_server_to_porcelain(plumbing.sql_server)
  end
  if plumbing.ssh != nil
    return convert_ssh_to_porcelain(plumbing.ssh)
  end
  if plumbing.ssh_cert != nil
    return convert_ssh_cert_to_porcelain(plumbing.ssh_cert)
  end
  if plumbing.ssh_customer_key != nil
    return convert_ssh_customer_key_to_porcelain(plumbing.ssh_customer_key)
  end
  if plumbing.sybase != nil
    return convert_sybase_to_porcelain(plumbing.sybase)
  end
  if plumbing.sybase_iq != nil
    return convert_sybase_iq_to_porcelain(plumbing.sybase_iq)
  end
  if plumbing.teradata != nil
    return convert_teradata_to_porcelain(plumbing.teradata)
  end
end

.convert_resource_update_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4829

def self.convert_resource_update_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::ResourceUpdateResponse.new()
  plumbing.meta = convert_update_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.resource = convert_resource_to_plumbing(porcelain.resource) unless porcelain.resource == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_resource_update_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4818

def self.convert_resource_update_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = ResourceUpdateResponse.new()
  porcelain.meta = convert_update_response_metadata_to_porcelain(plumbing.meta)
  porcelain.resource = convert_resource_to_porcelain(plumbing.resource)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_role_attachment_create_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4903

def self.convert_role_attachment_create_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleAttachmentCreateResponse.new()
  plumbing.meta = convert_create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.role_attachment = convert_role_attachment_to_plumbing(porcelain.role_attachment) unless porcelain.role_attachment == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_role_attachment_create_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4892

def self.convert_role_attachment_create_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleAttachmentCreateResponse.new()
  porcelain.meta = convert_create_response_metadata_to_porcelain(plumbing.meta)
  porcelain.role_attachment = convert_role_attachment_to_porcelain(plumbing.role_attachment)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_role_attachment_delete_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4978

def self.convert_role_attachment_delete_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleAttachmentDeleteResponse.new()
  plumbing.meta = convert_delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_role_attachment_delete_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4968

def self.convert_role_attachment_delete_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleAttachmentDeleteResponse.new()
  porcelain.meta = convert_delete_response_metadata_to_porcelain(plumbing.meta)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_role_attachment_get_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4941

def self.convert_role_attachment_get_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleAttachmentGetResponse.new()
  plumbing.meta = convert_get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.role_attachment = convert_role_attachment_to_plumbing(porcelain.role_attachment) unless porcelain.role_attachment == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_role_attachment_get_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4930

def self.convert_role_attachment_get_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleAttachmentGetResponse.new()
  porcelain.meta = convert_get_response_metadata_to_porcelain(plumbing.meta)
  porcelain.role_attachment = convert_role_attachment_to_porcelain(plumbing.role_attachment)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_role_attachment_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5015

def self.convert_role_attachment_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleAttachment.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.composite_role_id = (porcelain.composite_role_id) unless porcelain.composite_role_id == nil
  plumbing.attached_role_id = (porcelain.attached_role_id) unless porcelain.attached_role_id == nil
  plumbing
end

.convert_role_attachment_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5004

def self.convert_role_attachment_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleAttachment.new()
  porcelain.id = (plumbing.id)
  porcelain.composite_role_id = (plumbing.composite_role_id)
  porcelain.attached_role_id = (plumbing.attached_role_id)
  porcelain
end

.convert_role_create_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5203

def self.convert_role_create_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleCreateResponse.new()
  plumbing.meta = convert_create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.role = convert_role_to_plumbing(porcelain.role) unless porcelain.role == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_role_create_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5192

def self.convert_role_create_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleCreateResponse.new()
  porcelain.meta = convert_create_response_metadata_to_porcelain(plumbing.meta)
  porcelain.role = convert_role_to_porcelain(plumbing.role)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_role_delete_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5316

def self.convert_role_delete_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleDeleteResponse.new()
  plumbing.meta = convert_delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_role_delete_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5306

def self.convert_role_delete_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleDeleteResponse.new()
  porcelain.meta = convert_delete_response_metadata_to_porcelain(plumbing.meta)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_role_get_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5241

def self.convert_role_get_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleGetResponse.new()
  plumbing.meta = convert_get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.role = convert_role_to_plumbing(porcelain.role) unless porcelain.role == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_role_get_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5230

def self.convert_role_get_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleGetResponse.new()
  porcelain.meta = convert_get_response_metadata_to_porcelain(plumbing.meta)
  porcelain.role = convert_role_to_porcelain(plumbing.role)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_role_grant_create_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5053

def self.convert_role_grant_create_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleGrantCreateResponse.new()
  plumbing.meta = convert_create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.role_grant = convert_role_grant_to_plumbing(porcelain.role_grant) unless porcelain.role_grant == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_role_grant_create_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5042

def self.convert_role_grant_create_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleGrantCreateResponse.new()
  porcelain.meta = convert_create_response_metadata_to_porcelain(plumbing.meta)
  porcelain.role_grant = convert_role_grant_to_porcelain(plumbing.role_grant)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_role_grant_delete_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5128

def self.convert_role_grant_delete_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleGrantDeleteResponse.new()
  plumbing.meta = convert_delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_role_grant_delete_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5118

def self.convert_role_grant_delete_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleGrantDeleteResponse.new()
  porcelain.meta = convert_delete_response_metadata_to_porcelain(plumbing.meta)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_role_grant_get_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5091

def self.convert_role_grant_get_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleGrantGetResponse.new()
  plumbing.meta = convert_get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.role_grant = convert_role_grant_to_plumbing(porcelain.role_grant) unless porcelain.role_grant == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_role_grant_get_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5080

def self.convert_role_grant_get_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleGrantGetResponse.new()
  porcelain.meta = convert_get_response_metadata_to_porcelain(plumbing.meta)
  porcelain.role_grant = convert_role_grant_to_porcelain(plumbing.role_grant)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_role_grant_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5165

def self.convert_role_grant_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleGrant.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.resource_id = (porcelain.resource_id) unless porcelain.resource_id == nil
  plumbing.role_id = (porcelain.role_id) unless porcelain.role_id == nil
  plumbing
end

.convert_role_grant_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5154

def self.convert_role_grant_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleGrant.new()
  porcelain.id = (plumbing.id)
  porcelain.resource_id = (plumbing.resource_id)
  porcelain.role_id = (plumbing.role_id)
  porcelain
end

.convert_role_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5354

def self.convert_role_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Role.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.composite = (porcelain.composite) unless porcelain.composite == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing
end

.convert_role_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5342

def self.convert_role_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Role.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.composite = (plumbing.composite)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain
end

.convert_role_update_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5279

def self.convert_role_update_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::RoleUpdateResponse.new()
  plumbing.meta = convert_update_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.role = convert_role_to_plumbing(porcelain.role) unless porcelain.role == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_role_update_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5268

def self.convert_role_update_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = RoleUpdateResponse.new()
  porcelain.meta = convert_update_response_metadata_to_porcelain(plumbing.meta)
  porcelain.role = convert_role_to_porcelain(plumbing.role)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_secret_store_create_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5567

def self.convert_secret_store_create_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::SecretStoreCreateResponse.new()
  plumbing.meta = convert_create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.secret_store = convert_secret_store_to_plumbing(porcelain.secret_store) unless porcelain.secret_store == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_secret_store_create_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5556

def self.convert_secret_store_create_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = SecretStoreCreateResponse.new()
  porcelain.meta = convert_create_response_metadata_to_porcelain(plumbing.meta)
  porcelain.secret_store = convert_secret_store_to_porcelain(plumbing.secret_store)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_secret_store_delete_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5680

def self.convert_secret_store_delete_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::SecretStoreDeleteResponse.new()
  plumbing.meta = convert_delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_secret_store_delete_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5670

def self.convert_secret_store_delete_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = SecretStoreDeleteResponse.new()
  porcelain.meta = convert_delete_response_metadata_to_porcelain(plumbing.meta)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_secret_store_get_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5605

def self.convert_secret_store_get_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::SecretStoreGetResponse.new()
  plumbing.meta = convert_get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.secret_store = convert_secret_store_to_plumbing(porcelain.secret_store) unless porcelain.secret_store == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_secret_store_get_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5594

def self.convert_secret_store_get_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = SecretStoreGetResponse.new()
  porcelain.meta = convert_get_response_metadata_to_porcelain(plumbing.meta)
  porcelain.secret_store = convert_secret_store_to_porcelain(plumbing.secret_store)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_secret_store_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5382

def self.convert_secret_store_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::SecretStore.new()
  if porcelain.instance_of? AWSStore
    plumbing.aws = convert_aws_store_to_plumbing(porcelain)
  end
  if porcelain.instance_of? VaultTLSStore
    plumbing.vault_tls = convert_vault_tls_store_to_plumbing(porcelain)
  end
  if porcelain.instance_of? VaultTokenStore
    plumbing.vault_token = convert_vault_token_store_to_plumbing(porcelain)
  end
  plumbing
end

.convert_secret_store_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5399

def self.convert_secret_store_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  if plumbing.aws != nil
    return convert_aws_store_to_porcelain(plumbing.aws)
  end
  if plumbing.vault_tls != nil
    return convert_vault_tls_store_to_porcelain(plumbing.vault_tls)
  end
  if plumbing.vault_token != nil
    return convert_vault_token_store_to_porcelain(plumbing.vault_token)
  end
end

.convert_secret_store_update_response_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5643

def self.convert_secret_store_update_response_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::SecretStoreUpdateResponse.new()
  plumbing.meta = convert_update_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
  plumbing.secret_store = convert_secret_store_to_plumbing(porcelain.secret_store) unless porcelain.secret_store == nil
  plumbing.rate_limit = convert_rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
  plumbing
end

.convert_secret_store_update_response_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5632

def self.convert_secret_store_update_response_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = SecretStoreUpdateResponse.new()
  porcelain.meta = convert_update_response_metadata_to_porcelain(plumbing.meta)
  porcelain.secret_store = convert_secret_store_to_porcelain(plumbing.secret_store)
  porcelain.rate_limit = convert_rate_limit_metadata_to_porcelain(plumbing.rate_limit)
  porcelain
end

.convert_service_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 854

def self.convert_service_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Service.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.suspended = (porcelain.suspended) unless porcelain.suspended == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing
end

.convert_service_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 842

def self.convert_service_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Service.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.suspended = (plumbing.suspended)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain
end

.convert_snowflake_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4036

def self.convert_snowflake_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Snowflake.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.schema = (porcelain.schema) unless porcelain.schema == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing
end

.convert_snowflake_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4016

def self.convert_snowflake_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Snowflake.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.schema = (plumbing.schema)
  porcelain.port_override = (plumbing.port_override)
  porcelain
end

.convert_sql_server_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4094

def self.convert_sql_server_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::SQLServer.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.database = (porcelain.database) unless porcelain.database == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.schema = (porcelain.schema) unless porcelain.schema == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.override_database = (porcelain.override_database) unless porcelain.override_database == nil
  plumbing
end

.convert_sql_server_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4072

def self.convert_sql_server_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = SQLServer.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.database = (plumbing.database)
  porcelain.port_override = (plumbing.port_override)
  porcelain.schema = (plumbing.schema)
  porcelain.port = (plumbing.port)
  porcelain.override_database = (plumbing.override_database)
  porcelain
end

.convert_ssh_cert_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4207

def self.convert_ssh_cert_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::SSHCert.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.port_forwarding = (porcelain.port_forwarding) unless porcelain.port_forwarding == nil
  plumbing.allow_deprecated_key_exchanges = (porcelain.allow_deprecated_key_exchanges) unless porcelain.allow_deprecated_key_exchanges == nil
  plumbing
end

.convert_ssh_cert_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4188

def self.convert_ssh_cert_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = SSHCert.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.port = (plumbing.port)
  porcelain.port_forwarding = (plumbing.port_forwarding)
  porcelain.allow_deprecated_key_exchanges = (plumbing.allow_deprecated_key_exchanges)
  porcelain
end

.convert_ssh_customer_key_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4262

def self.convert_ssh_customer_key_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::SSHCustomerKey.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.private_key = (porcelain.private_key) unless porcelain.private_key == nil
  plumbing.port_forwarding = (porcelain.port_forwarding) unless porcelain.port_forwarding == nil
  plumbing.allow_deprecated_key_exchanges = (porcelain.allow_deprecated_key_exchanges) unless porcelain.allow_deprecated_key_exchanges == nil
  plumbing
end

.convert_ssh_customer_key_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4242

def self.convert_ssh_customer_key_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = SSHCustomerKey.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.port = (plumbing.port)
  porcelain.private_key = (plumbing.private_key)
  porcelain.port_forwarding = (plumbing.port_forwarding)
  porcelain.allow_deprecated_key_exchanges = (plumbing.allow_deprecated_key_exchanges)
  porcelain
end

.convert_ssh_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4152

def self.convert_ssh_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::SSH.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.public_key = (porcelain.public_key) unless porcelain.public_key == nil
  plumbing.port_forwarding = (porcelain.port_forwarding) unless porcelain.port_forwarding == nil
  plumbing.allow_deprecated_key_exchanges = (porcelain.allow_deprecated_key_exchanges) unless porcelain.allow_deprecated_key_exchanges == nil
  plumbing
end

.convert_ssh_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4132

def self.convert_ssh_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = SSH.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.port = (plumbing.port)
  porcelain.public_key = (plumbing.public_key)
  porcelain.port_forwarding = (plumbing.port_forwarding)
  porcelain.allow_deprecated_key_exchanges = (plumbing.allow_deprecated_key_exchanges)
  porcelain
end

.convert_sybase_iq_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4371

def self.convert_sybase_iq_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::SybaseIQ.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing
end

.convert_sybase_iq_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4352

def self.convert_sybase_iq_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = SybaseIQ.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.password = (plumbing.password)
  porcelain
end

.convert_sybase_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4317

def self.convert_sybase_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Sybase.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing
end

.convert_sybase_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4298

def self.convert_sybase_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Sybase.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain.password = (plumbing.password)
  porcelain
end

.convert_tag_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 274

def self.convert_tag_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Tag.new()
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.value = (porcelain.value) unless porcelain.value == nil
  plumbing
end

.convert_tag_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 264

def self.convert_tag_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Tag.new()
  porcelain.name = (plumbing.name)
  porcelain.value = (plumbing.value)
  porcelain
end

.convert_tags_to_plumbing(t) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 83

def self.convert_tags_to_plumbing(t)
  if t == nil
    return nil
  end
  tags = V1::Tags.new()
  t.each do |key, value|
    pair = V1::Tags::Pair.new()
    pair.name = key
    pair.value = value
    tags.pairs.push(pair)
  end
  tags
end

.convert_tags_to_porcelain(t) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 72

def self.convert_tags_to_porcelain(t)
  if t == nil
    return nil
  end
  res = {}
  t.pairs.each do |pair|
    res[pair.name] = pair.value
  end
  res
end

.convert_teradata_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4425

def self.convert_teradata_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::Teradata.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.healthy = (porcelain.healthy) unless porcelain.healthy == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing.secret_store_id = (porcelain.secret_store_id) unless porcelain.secret_store_id == nil
  plumbing.egress_filter = (porcelain.egress_filter) unless porcelain.egress_filter == nil
  plumbing.hostname = (porcelain.hostname) unless porcelain.hostname == nil
  plumbing.username = (porcelain.username) unless porcelain.username == nil
  plumbing.password = (porcelain.password) unless porcelain.password == nil
  plumbing.port_override = (porcelain.port_override) unless porcelain.port_override == nil
  plumbing.port = (porcelain.port) unless porcelain.port == nil
  plumbing
end

.convert_teradata_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 4406

def self.convert_teradata_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = Teradata.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.healthy = (plumbing.healthy)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain.secret_store_id = (plumbing.secret_store_id)
  porcelain.egress_filter = (plumbing.egress_filter)
  porcelain.hostname = (plumbing.hostname)
  porcelain.username = (plumbing.username)
  porcelain.password = (plumbing.password)
  porcelain.port_override = (plumbing.port_override)
  porcelain.port = (plumbing.port)
  porcelain
end

.convert_timestamp_to_plumbing(t) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 65

def self.convert_timestamp_to_plumbing(t)
  if t == nil
    return nil
  end
  return Google::Protobuf::Timestamp.new(seconds: t.to_i, nanos: t.nsec)
end

.convert_timestamp_to_porcelain(t) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 58

def self.convert_timestamp_to_porcelain(t)
  if t == nil
    return nil
  end
  return Time.at(t.seconds + t.nanos * (10 ** -9))
end

.convert_update_response_metadata_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 168

def self.convert_update_response_metadata_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::UpdateResponseMetadata.new()
  plumbing
end

.convert_update_response_metadata_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 160

def self.convert_update_response_metadata_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = UpdateResponseMetadata.new()
  porcelain
end

.convert_user_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 812

def self.convert_user_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::User.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.email = (porcelain.email) unless porcelain.email == nil
  plumbing.first_name = (porcelain.first_name) unless porcelain.first_name == nil
  plumbing.last_name = (porcelain.last_name) unless porcelain.last_name == nil
  plumbing.suspended = (porcelain.suspended) unless porcelain.suspended == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing
end

.convert_user_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 798

def self.convert_user_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = User.new()
  porcelain.id = (plumbing.id)
  porcelain.email = (plumbing.email)
  porcelain.first_name = (plumbing.first_name)
  porcelain.last_name = (plumbing.last_name)
  porcelain.suspended = (plumbing.suspended)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain
end

.convert_vault_tls_store_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5485

def self.convert_vault_tls_store_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::VaultTLSStore.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.server_address = (porcelain.server_address) unless porcelain.server_address == nil
  plumbing.CA_cert_path = (porcelain.ca_cert_path) unless porcelain.ca_cert_path == nil
  plumbing.client_cert_path = (porcelain.client_cert_path) unless porcelain.client_cert_path == nil
  plumbing.client_key_path = (porcelain.client_key_path) unless porcelain.client_key_path == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing
end

.convert_vault_tls_store_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5470

def self.convert_vault_tls_store_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = VaultTLSStore.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.server_address = (plumbing.server_address)
  porcelain.ca_cert_path = (plumbing.CA_cert_path)
  porcelain.client_cert_path = (plumbing.client_cert_path)
  porcelain.client_key_path = (plumbing.client_key_path)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain
end

.convert_vault_token_store_to_plumbing(porcelain) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5528

def self.convert_vault_token_store_to_plumbing(porcelain)
  if porcelain == nil
    return nil
  end
  plumbing = V1::VaultTokenStore.new()
  plumbing.id = (porcelain.id) unless porcelain.id == nil
  plumbing.name = (porcelain.name) unless porcelain.name == nil
  plumbing.server_address = (porcelain.server_address) unless porcelain.server_address == nil
  plumbing.tags = convert_tags_to_plumbing(porcelain.tags) unless porcelain.tags == nil
  plumbing
end

.convert_vault_token_store_to_porcelain(plumbing) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 5516

def self.convert_vault_token_store_to_porcelain(plumbing)
  if plumbing == nil
    return nil
  end
  porcelain = VaultTokenStore.new()
  porcelain.id = (plumbing.id)
  porcelain.name = (plumbing.name)
  porcelain.server_address = (plumbing.server_address)
  porcelain.tags = convert_tags_to_porcelain(plumbing.tags)
  porcelain
end

.quote_filter_args(filter, *args) ⇒ `Object`

# File 'lib/grpc/plumbing.rb', line 41

def self.quote_filter_args(filter, *args)
  parts = (filter + " ").split("?")
  if parts.length() != args.length() + 1
    raise BadRequestError.new("incorrect number of replacements")
  end
  b = ""
  parts.each_with_index do |v, i|
    b += v
    if i < args.length()
      s = args[i].to_s()
      s = JSON.dump(s)
      b += s
    end
  end
  return b
end

Module: SDM::Plumbing

Class Method Summary collapse

Class Method Details

.convert_account_attachment_create_response_to_plumbing(porcelain) ⇒ Object

.convert_account_attachment_create_response_to_porcelain(plumbing) ⇒ Object

.convert_account_attachment_delete_response_to_plumbing(porcelain) ⇒ Object

.convert_account_attachment_delete_response_to_porcelain(plumbing) ⇒ Object

.convert_account_attachment_get_response_to_plumbing(porcelain) ⇒ Object

.convert_account_attachment_get_response_to_porcelain(plumbing) ⇒ Object

.convert_account_attachment_to_plumbing(porcelain) ⇒ Object

.convert_account_attachment_to_porcelain(plumbing) ⇒ Object

.convert_account_create_response_to_plumbing(porcelain) ⇒ Object

.convert_account_create_response_to_porcelain(plumbing) ⇒ Object

.convert_account_delete_response_to_plumbing(porcelain) ⇒ Object

.convert_account_delete_response_to_porcelain(plumbing) ⇒ Object

.convert_account_get_response_to_plumbing(porcelain) ⇒ Object

.convert_account_get_response_to_porcelain(plumbing) ⇒ Object

.convert_account_grant_create_response_to_plumbing(porcelain) ⇒ Object

.convert_account_grant_create_response_to_porcelain(plumbing) ⇒ Object

.convert_account_grant_delete_response_to_plumbing(porcelain) ⇒ Object

.convert_account_grant_delete_response_to_porcelain(plumbing) ⇒ Object

.convert_account_grant_get_response_to_plumbing(porcelain) ⇒ Object

.convert_account_grant_get_response_to_porcelain(plumbing) ⇒ Object

.convert_account_grant_to_plumbing(porcelain) ⇒ Object

.convert_account_grant_to_porcelain(plumbing) ⇒ Object

.convert_account_to_plumbing(porcelain) ⇒ Object

.convert_account_to_porcelain(plumbing) ⇒ Object

.convert_account_update_response_to_plumbing(porcelain) ⇒ Object

.convert_account_update_response_to_porcelain(plumbing) ⇒ Object

.convert_aks_basic_auth_to_plumbing(porcelain) ⇒ Object

.convert_aks_basic_auth_to_porcelain(plumbing) ⇒ Object

.convert_aks_service_account_to_plumbing(porcelain) ⇒ Object

.convert_aks_service_account_to_porcelain(plumbing) ⇒ Object

.convert_aks_service_account_user_impersonation_to_plumbing(porcelain) ⇒ Object

.convert_aks_service_account_user_impersonation_to_porcelain(plumbing) ⇒ Object

.convert_aks_to_plumbing(porcelain) ⇒ Object

.convert_aks_to_porcelain(plumbing) ⇒ Object

.convert_aks_user_impersonation_to_plumbing(porcelain) ⇒ Object

.convert_aks_user_impersonation_to_porcelain(plumbing) ⇒ Object

.convert_amazon_eks_to_plumbing(porcelain) ⇒ Object

.convert_amazon_eks_to_porcelain(plumbing) ⇒ Object

.convert_amazon_eks_user_impersonation_to_plumbing(porcelain) ⇒ Object

.convert_amazon_eks_user_impersonation_to_porcelain(plumbing) ⇒ Object

.convert_amazon_es_to_plumbing(porcelain) ⇒ Object

.convert_amazon_es_to_porcelain(plumbing) ⇒ Object

.convert_athena_to_plumbing(porcelain) ⇒ Object

.convert_athena_to_porcelain(plumbing) ⇒ Object

.convert_aurora_mysql_to_plumbing(porcelain) ⇒ Object

.convert_aurora_mysql_to_porcelain(plumbing) ⇒ Object

.convert_aurora_postgres_to_plumbing(porcelain) ⇒ Object

.convert_aurora_postgres_to_porcelain(plumbing) ⇒ Object

.convert_aws_store_to_plumbing(porcelain) ⇒ Object

.convert_aws_store_to_porcelain(plumbing) ⇒ Object

.convert_aws_to_plumbing(porcelain) ⇒ Object

.convert_aws_to_porcelain(plumbing) ⇒ Object

.convert_big_query_to_plumbing(porcelain) ⇒ Object

.convert_big_query_to_porcelain(plumbing) ⇒ Object

.convert_cassandra_to_plumbing(porcelain) ⇒ Object

.convert_cassandra_to_porcelain(plumbing) ⇒ Object

.convert_citus_to_plumbing(porcelain) ⇒ Object

.convert_citus_to_porcelain(plumbing) ⇒ Object

.convert_clustrix_to_plumbing(porcelain) ⇒ Object

.convert_clustrix_to_porcelain(plumbing) ⇒ Object

.convert_cockroach_to_plumbing(porcelain) ⇒ Object

.convert_cockroach_to_porcelain(plumbing) ⇒ Object

.convert_control_panel_get_sshca_public_key_response_to_plumbing(porcelain) ⇒ Object

.convert_control_panel_get_sshca_public_key_response_to_porcelain(plumbing) ⇒ Object

.convert_control_panel_verify_jwt_response_to_plumbing(porcelain) ⇒ Object

.convert_control_panel_verify_jwt_response_to_porcelain(plumbing) ⇒ Object

.convert_create_response_metadata_to_plumbing(porcelain) ⇒ Object

.convert_create_response_metadata_to_porcelain(plumbing) ⇒ Object

.convert_db_2_i_to_plumbing(porcelain) ⇒ Object

.convert_db_2_i_to_porcelain(plumbing) ⇒ Object

.convert_db_2_luw_to_plumbing(porcelain) ⇒ Object

.convert_db_2_luw_to_porcelain(plumbing) ⇒ Object

.convert_delete_response_metadata_to_plumbing(porcelain) ⇒ Object

.convert_delete_response_metadata_to_porcelain(plumbing) ⇒ Object

.convert_druid_to_plumbing(porcelain) ⇒ Object

.convert_druid_to_porcelain(plumbing) ⇒ Object

.convert_dynamo_db_to_plumbing(porcelain) ⇒ Object

.convert_account_attachment_create_response_to_plumbing(porcelain) ⇒ `Object`

.convert_account_attachment_create_response_to_porcelain(plumbing) ⇒ `Object`

.convert_account_attachment_delete_response_to_plumbing(porcelain) ⇒ `Object`

.convert_account_attachment_delete_response_to_porcelain(plumbing) ⇒ `Object`

.convert_account_attachment_get_response_to_plumbing(porcelain) ⇒ `Object`

.convert_account_attachment_get_response_to_porcelain(plumbing) ⇒ `Object`

.convert_account_attachment_to_plumbing(porcelain) ⇒ `Object`

.convert_account_attachment_to_porcelain(plumbing) ⇒ `Object`

.convert_account_create_response_to_plumbing(porcelain) ⇒ `Object`

.convert_account_create_response_to_porcelain(plumbing) ⇒ `Object`

.convert_account_delete_response_to_plumbing(porcelain) ⇒ `Object`

.convert_account_delete_response_to_porcelain(plumbing) ⇒ `Object`

.convert_account_get_response_to_plumbing(porcelain) ⇒ `Object`

.convert_account_get_response_to_porcelain(plumbing) ⇒ `Object`

.convert_account_grant_create_response_to_plumbing(porcelain) ⇒ `Object`

.convert_account_grant_create_response_to_porcelain(plumbing) ⇒ `Object`

.convert_account_grant_delete_response_to_plumbing(porcelain) ⇒ `Object`

.convert_account_grant_delete_response_to_porcelain(plumbing) ⇒ `Object`

.convert_account_grant_get_response_to_plumbing(porcelain) ⇒ `Object`

.convert_account_grant_get_response_to_porcelain(plumbing) ⇒ `Object`

.convert_account_grant_to_plumbing(porcelain) ⇒ `Object`

.convert_account_grant_to_porcelain(plumbing) ⇒ `Object`

.convert_account_to_plumbing(porcelain) ⇒ `Object`

.convert_account_to_porcelain(plumbing) ⇒ `Object`

.convert_account_update_response_to_plumbing(porcelain) ⇒ `Object`

.convert_account_update_response_to_porcelain(plumbing) ⇒ `Object`

.convert_aks_basic_auth_to_plumbing(porcelain) ⇒ `Object`

.convert_aks_basic_auth_to_porcelain(plumbing) ⇒ `Object`

.convert_aks_service_account_to_plumbing(porcelain) ⇒ `Object`

.convert_aks_service_account_to_porcelain(plumbing) ⇒ `Object`

.convert_aks_service_account_user_impersonation_to_plumbing(porcelain) ⇒ `Object`

.convert_aks_service_account_user_impersonation_to_porcelain(plumbing) ⇒ `Object`

.convert_aks_to_plumbing(porcelain) ⇒ `Object`

.convert_aks_to_porcelain(plumbing) ⇒ `Object`

.convert_aks_user_impersonation_to_plumbing(porcelain) ⇒ `Object`

.convert_aks_user_impersonation_to_porcelain(plumbing) ⇒ `Object`

.convert_amazon_eks_to_plumbing(porcelain) ⇒ `Object`

.convert_amazon_eks_to_porcelain(plumbing) ⇒ `Object`

.convert_amazon_eks_user_impersonation_to_plumbing(porcelain) ⇒ `Object`

.convert_amazon_eks_user_impersonation_to_porcelain(plumbing) ⇒ `Object`

.convert_amazon_es_to_plumbing(porcelain) ⇒ `Object`

.convert_amazon_es_to_porcelain(plumbing) ⇒ `Object`

.convert_athena_to_plumbing(porcelain) ⇒ `Object`

.convert_athena_to_porcelain(plumbing) ⇒ `Object`

.convert_aurora_mysql_to_plumbing(porcelain) ⇒ `Object`

.convert_aurora_mysql_to_porcelain(plumbing) ⇒ `Object`

.convert_aurora_postgres_to_plumbing(porcelain) ⇒ `Object`

.convert_aurora_postgres_to_porcelain(plumbing) ⇒ `Object`

.convert_aws_store_to_plumbing(porcelain) ⇒ `Object`

.convert_aws_store_to_porcelain(plumbing) ⇒ `Object`

.convert_aws_to_plumbing(porcelain) ⇒ `Object`

.convert_aws_to_porcelain(plumbing) ⇒ `Object`

.convert_big_query_to_plumbing(porcelain) ⇒ `Object`

.convert_big_query_to_porcelain(plumbing) ⇒ `Object`

.convert_cassandra_to_plumbing(porcelain) ⇒ `Object`

.convert_cassandra_to_porcelain(plumbing) ⇒ `Object`

.convert_citus_to_plumbing(porcelain) ⇒ `Object`

.convert_citus_to_porcelain(plumbing) ⇒ `Object`

.convert_clustrix_to_plumbing(porcelain) ⇒ `Object`

.convert_clustrix_to_porcelain(plumbing) ⇒ `Object`

.convert_cockroach_to_plumbing(porcelain) ⇒ `Object`

.convert_cockroach_to_porcelain(plumbing) ⇒ `Object`

.convert_control_panel_get_sshca_public_key_response_to_plumbing(porcelain) ⇒ `Object`

.convert_control_panel_get_sshca_public_key_response_to_porcelain(plumbing) ⇒ `Object`

.convert_control_panel_verify_jwt_response_to_plumbing(porcelain) ⇒ `Object`

.convert_control_panel_verify_jwt_response_to_porcelain(plumbing) ⇒ `Object`

.convert_create_response_metadata_to_plumbing(porcelain) ⇒ `Object`

.convert_create_response_metadata_to_porcelain(plumbing) ⇒ `Object`

.convert_db_2_i_to_plumbing(porcelain) ⇒ `Object`

.convert_db_2_i_to_porcelain(plumbing) ⇒ `Object`

.convert_db_2_luw_to_plumbing(porcelain) ⇒ `Object`

.convert_db_2_luw_to_porcelain(plumbing) ⇒ `Object`

.convert_delete_response_metadata_to_plumbing(porcelain) ⇒ `Object`

.convert_delete_response_metadata_to_porcelain(plumbing) ⇒ `Object`

.convert_druid_to_plumbing(porcelain) ⇒ `Object`

.convert_druid_to_porcelain(plumbing) ⇒ `Object`

.convert_dynamo_db_to_plumbing(porcelain) ⇒ `Object`

.convert_dynamo_db_to_porcelain(plumbing) ⇒ `Object`

.convert_elastic_to_plumbing(porcelain) ⇒ `Object`

.convert_elastic_to_porcelain(plumbing) ⇒ `Object`