Module: SDM::Plumbing

Defined in:: lib/grpc/plumbing.rb

Class Method Summary collapse

Class Method Details

.convert_account_attachment_create_options_to_plumbing(porcelain) ⇒ `Object`

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

def self.convert_account_attachment_create_options_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::AccountAttachmentCreateOptions.new()
    plumbing.overwrite = (porcelain.overwrite) unless porcelain.overwrite == nil
    plumbing
end

.convert_account_attachment_create_options_to_porcelain(plumbing) ⇒ `Object`

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

def self.convert_account_attachment_create_options_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = AccountAttachmentCreateOptions.new()
    porcelain.overwrite = (plumbing.overwrite)
    porcelain
end

.convert_account_attachment_create_response_to_plumbing(porcelain) ⇒ `Object`

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

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 296

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 382

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 372

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 345

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 334

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 419

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 408

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 612

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 600

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 726

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 716

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 651

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 640

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 457

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 446

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 532

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 522

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 495

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 484

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 571

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 558

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 752

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 766

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 689

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 678

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 2006

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.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
end

.convert_aks_basic_auth_to_porcelain(plumbing) ⇒ `Object`

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

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.hostname = (plumbing.hostname)
    porcelain.port = (plumbing.port)
    porcelain.username = (plumbing.username)
    porcelain.password = (plumbing.password)
    porcelain
end

.convert_aks_service_account_to_plumbing(porcelain) ⇒ `Object`

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

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.hostname = (porcelain.hostname) unless porcelain.hostname == nil
    plumbing.port = (porcelain.port) unless porcelain.port == nil
    plumbing.token = (porcelain.token) unless porcelain.token == nil
    plumbing
end

.convert_aks_service_account_to_porcelain(plumbing) ⇒ `Object`

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

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.hostname = (plumbing.hostname)
    porcelain.port = (plumbing.port)
    porcelain.token = (plumbing.token)
    porcelain
end

.convert_aks_to_plumbing(porcelain) ⇒ `Object`

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

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.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.certificate_authority_filename = (porcelain.certificate_authority_filename) unless porcelain.certificate_authority_filename == nil
    plumbing.client_certificate = (porcelain.client_certificate) unless porcelain.client_certificate == nil
    plumbing.client_certificate_filename = (porcelain.client_certificate_filename) unless porcelain.client_certificate_filename == nil
    plumbing.client_key = (porcelain.client_key) unless porcelain.client_key == nil
    plumbing.client_key_filename = (porcelain.client_key_filename) unless porcelain.client_key_filename == nil
    plumbing
end

.convert_aks_to_porcelain(plumbing) ⇒ `Object`

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

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.hostname = (plumbing.hostname)
    porcelain.port = (plumbing.port)
    porcelain.certificate_authority = (plumbing.certificate_authority)
    porcelain.certificate_authority_filename = (plumbing.certificate_authority_filename)
    porcelain.client_certificate = (plumbing.client_certificate)
    porcelain.client_certificate_filename = (plumbing.client_certificate_filename)
    porcelain.client_key = (plumbing.client_key)
    porcelain.client_key_filename = (plumbing.client_key_filename)
    porcelain
end

.convert_amazon_eks_to_plumbing(porcelain) ⇒ `Object`

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

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.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.certificate_authority_filename = (porcelain.certificate_authority_filename) unless porcelain.certificate_authority_filename == 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
end

.convert_amazon_eks_to_porcelain(plumbing) ⇒ `Object`

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

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.endpoint = (plumbing.endpoint)
    porcelain.access_key = (plumbing.access_key)
    porcelain.secret_access_key = (plumbing.secret_access_key)
    porcelain.certificate_authority = (plumbing.certificate_authority)
    porcelain.certificate_authority_filename = (plumbing.certificate_authority_filename)
    porcelain.region = (plumbing.region)
    porcelain.cluster_name = (plumbing.cluster_name)
    porcelain.role_arn = (plumbing.role_arn)
    porcelain
end

.convert_amazon_es_to_plumbing(porcelain) ⇒ `Object`

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

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.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
end

.convert_amazon_es_to_porcelain(plumbing) ⇒ `Object`

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

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.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
end

.convert_athena_to_plumbing(porcelain) ⇒ `Object`

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

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.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
end

.convert_athena_to_porcelain(plumbing) ⇒ `Object`

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

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.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
end

.convert_aurora_mysql_to_plumbing(porcelain) ⇒ `Object`

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

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.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 2408

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.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 2743

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.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 2724

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.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_big_query_to_plumbing(porcelain) ⇒ `Object`

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

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.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 1218

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.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 1286

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.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 1268

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.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_clustrix_to_plumbing(porcelain) ⇒ `Object`

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

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.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 2460

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.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 2851

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.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 2832

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.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_create_response_metadata_to_plumbing(porcelain) ⇒ `Object`

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

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 94

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

.convert_delete_response_metadata_to_plumbing(porcelain) ⇒ `Object`

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

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 190

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 1337

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.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 1320

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.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 1387

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.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
end

.convert_dynamo_db_to_porcelain(plumbing) ⇒ `Object`

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

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.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
end

.convert_elastic_to_plumbing(porcelain) ⇒ `Object`

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

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.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 1470

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.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 3109

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.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 3092

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.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 4362

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 3695

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
end

.convert_gateway_to_porcelain(plumbing) ⇒ `Object`

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

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
end

.convert_get_response_metadata_to_plumbing(porcelain) ⇒ `Object`

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

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 126

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 1901

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.endpoint = (porcelain.endpoint) unless porcelain.endpoint == nil
    plumbing.certificate_authority = (porcelain.certificate_authority) unless porcelain.certificate_authority == nil
    plumbing.certificate_authority_filename = (porcelain.certificate_authority_filename) unless porcelain.certificate_authority_filename == nil
    plumbing.service_account_key = (porcelain.service_account_key) unless porcelain.service_account_key == nil
    plumbing.service_account_key_filename = (porcelain.service_account_key_filename) unless porcelain.service_account_key_filename == nil
    plumbing
end

.convert_google_gke_to_porcelain(plumbing) ⇒ `Object`

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

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.endpoint = (plumbing.endpoint)
    porcelain.certificate_authority = (plumbing.certificate_authority)
    porcelain.certificate_authority_filename = (plumbing.certificate_authority_filename)
    porcelain.service_account_key = (plumbing.service_account_key)
    porcelain.service_account_key_filename = (plumbing.service_account_key_filename)
    porcelain
end

.convert_greenplum_to_plumbing(porcelain) ⇒ `Object`

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

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.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 2778

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.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 1644

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.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 1626

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.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 1541

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.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 1522

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.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 1593

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.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 1576

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.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 1750

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.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
end

.convert_kubernetes_basic_auth_to_porcelain(plumbing) ⇒ `Object`

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

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.hostname = (plumbing.hostname)
    porcelain.port = (plumbing.port)
    porcelain.username = (plumbing.username)
    porcelain.password = (plumbing.password)
    porcelain
end

.convert_kubernetes_service_account_to_plumbing(porcelain) ⇒ `Object`

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

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.hostname = (porcelain.hostname) unless porcelain.hostname == nil
    plumbing.port = (porcelain.port) unless porcelain.port == nil
    plumbing.token = (porcelain.token) unless porcelain.token == nil
    plumbing
end

.convert_kubernetes_service_account_to_porcelain(plumbing) ⇒ `Object`

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

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.hostname = (plumbing.hostname)
    porcelain.port = (plumbing.port)
    porcelain.token = (plumbing.token)
    porcelain
end

.convert_kubernetes_to_plumbing(porcelain) ⇒ `Object`

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

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.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.certificate_authority_filename = (porcelain.certificate_authority_filename) unless porcelain.certificate_authority_filename == nil
    plumbing.client_certificate = (porcelain.client_certificate) unless porcelain.client_certificate == nil
    plumbing.client_certificate_filename = (porcelain.client_certificate_filename) unless porcelain.client_certificate_filename == nil
    plumbing.client_key = (porcelain.client_key) unless porcelain.client_key == nil
    plumbing.client_key_filename = (porcelain.client_key_filename) unless porcelain.client_key_filename == nil
    plumbing
end

.convert_kubernetes_to_porcelain(plumbing) ⇒ `Object`

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

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.hostname = (plumbing.hostname)
    porcelain.port = (plumbing.port)
    porcelain.certificate_authority = (plumbing.certificate_authority)
    porcelain.certificate_authority_filename = (plumbing.certificate_authority_filename)
    porcelain.client_certificate = (plumbing.client_certificate)
    porcelain.client_certificate_filename = (plumbing.client_certificate_filename)
    porcelain.client_key = (plumbing.client_key)
    porcelain.client_key_filename = (plumbing.client_key_filename)
    porcelain
end

.convert_maria_to_plumbing(porcelain) ⇒ `Object`

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

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.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 2512

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.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 2099

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.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 2084

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.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 2582

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.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 2564

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.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 2263

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.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 2244

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.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 2150

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.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 2130

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.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 2207

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.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 2186

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.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 2319

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.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 2298

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.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 2374

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.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 2356

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.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 3462

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 3450

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 3576

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 3566

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 3501

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 3490

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 3602

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 3616

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 3539

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 3528

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 2635

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.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 2616

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.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 2689

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.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 2670

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.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 2959

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.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 2940

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.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 234

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 222

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 3011

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.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 2994

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.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 3060

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.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 3044

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.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 2905

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.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 2886

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.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 3655

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
end

.convert_relay_to_porcelain(plumbing) ⇒ `Object`

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

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
end

.convert_repeated_account_attachment_create_options_to_plumbing(porcelains) ⇒ `Object`

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

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

.convert_repeated_account_attachment_create_options_to_porcelain(plumbings) ⇒ `Object`

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

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

.convert_repeated_account_attachment_create_response_to_plumbing(porcelains) ⇒ `Object`

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

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 326

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 391

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 400

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 355

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 364

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 429

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 438

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 623

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 632

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 735

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 744

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 661

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 670

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 467

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 476

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 541

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 550

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 505

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 514

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 583

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 592

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 777

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 786

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 699

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 708

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 2021

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 2030

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 2067

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 2076

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_to_plumbing(porcelains) ⇒ `Object`

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

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 1982

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_amazon_eks_to_plumbing(porcelains) ⇒ `Object`

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

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 1876

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_es_to_plumbing(porcelains) ⇒ `Object`

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

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 1462

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 1201

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 1210

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 2443

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 2452

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 2761

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 2770

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_big_query_to_plumbing(porcelains) ⇒ `Object`

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

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 1260

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 1303

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 1312

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_clustrix_to_plumbing(porcelains) ⇒ `Object`

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

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 2504

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 2869

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 2878

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_create_response_metadata_to_plumbing(porcelains) ⇒ `Object`

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

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 118

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_delete_response_metadata_to_plumbing(porcelains) ⇒ `Object`

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

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 214

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 1353

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 1362

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 1403

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 1412

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 1505

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 1514

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 3125

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 3134

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 3707

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 3716

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 141

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 150

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 1917

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 1926

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_greenplum_to_plumbing(porcelains) ⇒ `Object`

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

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 2824

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 1661

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 1670

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 1559

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 1568

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 1609

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 1618

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 1765

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 1774

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 1811

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 1820

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_to_plumbing(porcelains) ⇒ `Object`

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

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 1726

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_maria_to_plumbing(porcelains) ⇒ `Object`

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

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 2556

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 2113

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 2122

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 2599

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 2608

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 2281

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 2290

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 2169

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 2178

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 2227

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 2236

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 2339

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 2348

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 2391

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 2400

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 3473

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 3482

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 3585

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 3594

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 3511

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 3520

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 3627

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 3636

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 3549

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 3558

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 2653

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 2662

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 2707

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 2716

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 2977

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 2986

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 245

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 254

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 3027

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 3036

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 3075

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 3084

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 2923

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 2932

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 3665

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 3674

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 3745

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 3754

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 3857

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 3866

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 3783

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 3792

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 1151

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 1160

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 3821

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 3830

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 3895

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 3904

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 3969

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 3978

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 3933

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 3942

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 4007

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 4016

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 4195

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 4204

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 4307

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 4316

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 4233

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 4242

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 4045

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 4054

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 4119

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 4128

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 4083

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 4092

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 4157

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 4166

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 4345

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 4354

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 4271

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 4280

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_service_to_plumbing(porcelains) ⇒ `Object`

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

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 866

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 3177

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 3186

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 3233

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 3242

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_to_plumbing(porcelains) ⇒ `Object`

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

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 3292

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 3383

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 3392

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 3333

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 3342

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_teradata_to_plumbing(porcelains) ⇒ `Object`

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

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 3442

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 173

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 182

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 819

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 828

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_resource_create_response_to_plumbing(porcelain) ⇒ `Object`

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

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 3724

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 3848

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 3838

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 3773

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 3762

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 874

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? 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? 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? 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? AmazonEKS
        plumbing.amazon_eks = convert_amazon_eks_to_plumbing(porcelain)
    end
    if porcelain .instance_of? GoogleGKE
        plumbing.google_gke = convert_google_gke_to_plumbing(porcelain)
    end
    if porcelain .instance_of? AKS
        plumbing.aks = convert_aks_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? 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? 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? 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 1014

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.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.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_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.amazon_eks != nil
        return convert_amazon_eks_to_porcelain(plumbing.amazon_eks)
    end
    if plumbing.google_gke != nil
        return convert_google_gke_to_porcelain(plumbing.google_gke)
    end
    if plumbing.aks != nil
        return convert_aks_to_porcelain(plumbing.aks)
    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.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.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.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 3811

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 3800

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 3885

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 3874

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 3960

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 3950

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 3923

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 3912

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 3997

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 3986

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 4185

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 4174

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 4298

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 4288

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 4223

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 4212

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 4035

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 4024

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 4110

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 4100

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 4073

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 4062

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 4147

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 4136

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 4335

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
end

.convert_role_to_porcelain(plumbing) ⇒ `Object`

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

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
end

.convert_role_update_response_to_plumbing(porcelain) ⇒ `Object`

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

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 4250

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_service_to_plumbing(porcelain) ⇒ `Object`

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

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
end

.convert_service_to_porcelain(plumbing) ⇒ `Object`

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

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
end

.convert_snowflake_to_plumbing(porcelain) ⇒ `Object`

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

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.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 3142

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.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 3214

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.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 3194

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.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_to_plumbing(porcelain) ⇒ `Object`

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

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.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
end

.convert_ssh_to_porcelain(plumbing) ⇒ `Object`

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

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.hostname = (plumbing.hostname)
    porcelain.username = (plumbing.username)
    porcelain.port = (plumbing.port)
    porcelain.public_key = (plumbing.public_key)
    porcelain.port_forwarding = (plumbing.port_forwarding)
    porcelain
end

.convert_sybase_iq_to_plumbing(porcelain) ⇒ `Object`

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

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.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 3350

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.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 3317

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.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 3300

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.hostname = (plumbing.hostname)
    porcelain.username = (plumbing.username)
    porcelain.port_override = (plumbing.port_override)
    porcelain.port = (plumbing.port)
    porcelain.password = (plumbing.password)
    porcelain
end

.convert_tags_to_plumbing(t) ⇒ `Object`

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

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 70

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 3417

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.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 3400

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.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 63

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 56

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 166

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 158

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 807

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
end

.convert_user_to_porcelain(plumbing) ⇒ `Object`

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

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
end

.quote_filter_args(filter, *args) ⇒ `Object`

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

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_options_to_plumbing(porcelain) ⇒ Object

.convert_account_attachment_create_options_to_porcelain(plumbing) ⇒ 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_to_plumbing(porcelain) ⇒ Object

.convert_aks_to_porcelain(plumbing) ⇒ Object

.convert_amazon_eks_to_plumbing(porcelain) ⇒ Object

.convert_amazon_eks_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_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_clustrix_to_plumbing(porcelain) ⇒ Object

.convert_clustrix_to_porcelain(plumbing) ⇒ Object

.convert_cockroach_to_plumbing(porcelain) ⇒ Object

.convert_cockroach_to_porcelain(plumbing) ⇒ Object

.convert_create_response_metadata_to_plumbing(porcelain) ⇒ Object

.convert_create_response_metadata_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

.convert_elasticache_redis_to_plumbing(porcelain) ⇒ Object

.convert_elasticache_redis_to_porcelain(plumbing) ⇒ Object

.convert_error_to_porcelain(err) ⇒ Object

.convert_gateway_to_plumbing(porcelain) ⇒ Object

.convert_gateway_to_porcelain(plumbing) ⇒ Object

.convert_get_response_metadata_to_plumbing(porcelain) ⇒ Object

.convert_get_response_metadata_to_porcelain(plumbing) ⇒ Object

.convert_google_gke_to_plumbing(porcelain) ⇒ Object

.convert_google_gke_to_porcelain(plumbing) ⇒ Object

.convert_greenplum_to_plumbing(porcelain) ⇒ Object

.convert_greenplum_to_porcelain(plumbing) ⇒ Object

.convert_http_auth_to_plumbing(porcelain) ⇒ Object

.convert_http_auth_to_porcelain(plumbing) ⇒ Object

.convert_http_basic_auth_to_plumbing(porcelain) ⇒ Object

.convert_http_basic_auth_to_porcelain(plumbing) ⇒ Object

.convert_account_attachment_create_options_to_plumbing(porcelain) ⇒ `Object`

.convert_account_attachment_create_options_to_porcelain(plumbing) ⇒ `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_to_plumbing(porcelain) ⇒ `Object`

.convert_aks_to_porcelain(plumbing) ⇒ `Object`

.convert_amazon_eks_to_plumbing(porcelain) ⇒ `Object`

.convert_amazon_eks_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_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_clustrix_to_plumbing(porcelain) ⇒ `Object`

.convert_clustrix_to_porcelain(plumbing) ⇒ `Object`

.convert_cockroach_to_plumbing(porcelain) ⇒ `Object`

.convert_cockroach_to_porcelain(plumbing) ⇒ `Object`

.convert_create_response_metadata_to_plumbing(porcelain) ⇒ `Object`

.convert_create_response_metadata_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`

.convert_elasticache_redis_to_plumbing(porcelain) ⇒ `Object`

.convert_elasticache_redis_to_porcelain(plumbing) ⇒ `Object`

.convert_error_to_porcelain(err) ⇒ `Object`

.convert_gateway_to_plumbing(porcelain) ⇒ `Object`

.convert_gateway_to_porcelain(plumbing) ⇒ `Object`

.convert_get_response_metadata_to_plumbing(porcelain) ⇒ `Object`

.convert_get_response_metadata_to_porcelain(plumbing) ⇒ `Object`

.convert_google_gke_to_plumbing(porcelain) ⇒ `Object`

.convert_google_gke_to_porcelain(plumbing) ⇒ `Object`

.convert_greenplum_to_plumbing(porcelain) ⇒ `Object`

.convert_greenplum_to_porcelain(plumbing) ⇒ `Object`

.convert_http_auth_to_plumbing(porcelain) ⇒ `Object`

.convert_http_auth_to_porcelain(plumbing) ⇒ `Object`

.convert_http_basic_auth_to_plumbing(porcelain) ⇒ `Object`

.convert_http_basic_auth_to_porcelain(plumbing) ⇒ `Object`

.convert_http_no_auth_to_plumbing(porcelain) ⇒ `Object`

.convert_http_no_auth_to_porcelain(plumbing) ⇒ `Object`

.convert_kubernetes_basic_auth_to_plumbing(porcelain) ⇒ `Object`