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

.account_attachment_create_options_to_plumbing(porcelain) ⇒ `Object`

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

def self.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

.account_attachment_create_options_to_porcelain(plumbing) ⇒ `Object`

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

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

.account_attachment_create_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.account_attachment_create_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::AccountAttachmentCreateResponse.new()
    plumbing.meta = create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.account_attachment = account_attachment_to_plumbing(porcelain.account_attachment) unless porcelain.account_attachment == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.account_attachment_create_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.account_attachment_create_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = AccountAttachmentCreateResponse.new()
    porcelain.meta = create_response_metadata_to_porcelain(plumbing.meta)
    porcelain.account_attachment = account_attachment_to_porcelain(plumbing.account_attachment)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.account_attachment_delete_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.account_attachment_delete_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::AccountAttachmentDeleteResponse.new()
    plumbing.meta = delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.account_attachment_delete_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.account_attachment_delete_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = AccountAttachmentDeleteResponse.new()
    porcelain.meta = delete_response_metadata_to_porcelain(plumbing.meta)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.account_attachment_get_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.account_attachment_get_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::AccountAttachmentGetResponse.new()
    plumbing.meta = get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.account_attachment = account_attachment_to_plumbing(porcelain.account_attachment) unless porcelain.account_attachment == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.account_attachment_get_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.account_attachment_get_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = AccountAttachmentGetResponse.new()
    porcelain.meta = get_response_metadata_to_porcelain(plumbing.meta)
    porcelain.account_attachment = account_attachment_to_porcelain(plumbing.account_attachment)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.account_attachment_to_plumbing(porcelain) ⇒ `Object`

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

def self.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

.account_attachment_to_porcelain(plumbing) ⇒ `Object`

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

def self.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

.account_create_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.account_create_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::AccountCreateResponse.new()
    plumbing.meta = create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.account = account_to_plumbing(porcelain.account) unless porcelain.account == nil
    plumbing.token = porcelain.token unless porcelain.token == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.account_create_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.account_create_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = AccountCreateResponse.new()
    porcelain.meta = create_response_metadata_to_porcelain(plumbing.meta)
    porcelain.account = account_to_porcelain(plumbing.account)
    porcelain.token = plumbing.token
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.account_delete_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.account_delete_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::AccountDeleteResponse.new()
    plumbing.meta = delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.account_delete_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.account_delete_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = AccountDeleteResponse.new()
    porcelain.meta = delete_response_metadata_to_porcelain(plumbing.meta)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.account_get_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.account_get_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::AccountGetResponse.new()
    plumbing.meta = get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.account = account_to_plumbing(porcelain.account) unless porcelain.account == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.account_get_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.account_get_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = AccountGetResponse.new()
    porcelain.meta = get_response_metadata_to_porcelain(plumbing.meta)
    porcelain.account = account_to_porcelain(plumbing.account)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.account_grant_create_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.account_grant_create_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::AccountGrantCreateResponse.new()
    plumbing.meta = create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.account_grant = account_grant_to_plumbing(porcelain.account_grant) unless porcelain.account_grant == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.account_grant_create_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.account_grant_create_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = AccountGrantCreateResponse.new()
    porcelain.meta = create_response_metadata_to_porcelain(plumbing.meta)
    porcelain.account_grant = account_grant_to_porcelain(plumbing.account_grant)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.account_grant_delete_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.account_grant_delete_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::AccountGrantDeleteResponse.new()
    plumbing.meta = delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.account_grant_delete_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.account_grant_delete_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = AccountGrantDeleteResponse.new()
    porcelain.meta = delete_response_metadata_to_porcelain(plumbing.meta)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.account_grant_get_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.account_grant_get_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::AccountGrantGetResponse.new()
    plumbing.meta = get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.account_grant = account_grant_to_plumbing(porcelain.account_grant) unless porcelain.account_grant == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.account_grant_get_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.account_grant_get_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = AccountGrantGetResponse.new()
    porcelain.meta = get_response_metadata_to_porcelain(plumbing.meta)
    porcelain.account_grant = account_grant_to_porcelain(plumbing.account_grant)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.account_grant_to_plumbing(porcelain) ⇒ `Object`

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

def self.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 = timestamp_to_plumbing(porcelain.start_from) unless porcelain.start_from == nil
    plumbing.valid_until = timestamp_to_plumbing(porcelain.valid_until) unless porcelain.valid_until == nil
    plumbing
end

.account_grant_to_porcelain(plumbing) ⇒ `Object`

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

def self.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 = timestamp_to_porcelain(plumbing.start_from)
    porcelain.valid_until = timestamp_to_porcelain(plumbing.valid_until)
    porcelain
end

.account_to_plumbing(porcelain) ⇒ `Object`

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

def self.account_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::Account.new()
    if porcelain .instance_of? User
        plumbing.user = user_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Service
        plumbing.service = service_to_plumbing(porcelain)
    end
    plumbing
end

.account_to_porcelain(plumbing) ⇒ `Object`

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

def self.account_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    if plumbing.user != nil
        return user_to_porcelain(plumbing.user)
    end
    if plumbing.service != nil
        return service_to_porcelain(plumbing.service)
    end
end

.account_update_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.account_update_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::AccountUpdateResponse.new()
    plumbing.meta = update_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.account = account_to_plumbing(porcelain.account) unless porcelain.account == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.account_update_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.account_update_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = AccountUpdateResponse.new()
    porcelain.meta = update_response_metadata_to_porcelain(plumbing.meta)
    porcelain.account = account_to_porcelain(plumbing.account)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.aks_basic_auth_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.aks_basic_auth_to_porcelain(plumbing) ⇒ `Object`

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

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

.aks_service_account_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.aks_service_account_to_porcelain(plumbing) ⇒ `Object`

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

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

.aks_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.aks_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.amazon_eks_to_plumbing(porcelain) ⇒ `Object`

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

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

.amazon_eks_to_porcelain(plumbing) ⇒ `Object`

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

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

.amazon_es_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.amazon_es_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.athena_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.athena_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.aurora_mysql_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.aurora_mysql_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.aurora_postgres_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.aurora_postgres_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.big_query_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.big_query_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.cassandra_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.cassandra_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.clustrix_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.clustrix_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.cockroach_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.cockroach_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.create_response_metadata_to_plumbing(porcelain) ⇒ `Object`

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

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

.create_response_metadata_to_porcelain(plumbing) ⇒ `Object`

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

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

.delete_response_metadata_to_plumbing(porcelain) ⇒ `Object`

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

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

.delete_response_metadata_to_porcelain(plumbing) ⇒ `Object`

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

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

.druid_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.druid_to_porcelain(plumbing) ⇒ `Object`

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

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

.dynamo_db_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.dynamo_db_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.elastic_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.elastic_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.elasticache_redis_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.elasticache_redis_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.error_to_porcelain(err) ⇒ `Object`

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

def self.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, 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

.gateway_to_plumbing(porcelain) ⇒ `Object`

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

def self.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

.gateway_to_porcelain(plumbing) ⇒ `Object`

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

def self.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

.get_response_metadata_to_plumbing(porcelain) ⇒ `Object`

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

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

.get_response_metadata_to_porcelain(plumbing) ⇒ `Object`

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

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

.google_gke_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.google_gke_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.greenplum_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.greenplum_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.http_auth_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.http_auth_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.http_basic_auth_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.http_basic_auth_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.http_no_auth_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.http_no_auth_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.kubernetes_basic_auth_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.kubernetes_basic_auth_to_porcelain(plumbing) ⇒ `Object`

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

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

.kubernetes_service_account_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.kubernetes_service_account_to_porcelain(plumbing) ⇒ `Object`

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

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

.kubernetes_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.kubernetes_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.maria_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.maria_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.memcached_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.memcached_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.hostname = plumbing.hostname
    porcelain.port_override = plumbing.port_override
    porcelain.port = plumbing.port
    porcelain
end

.memsql_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.memsql_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.mongo_host_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.mongo_host_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.mongo_legacy_host_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.mongo_legacy_host_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.mongo_legacy_replicaset_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.mongo_legacy_replicaset_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.mongo_replica_set_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.mongo_replica_set_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.mysql_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.mysql_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.node_create_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.node_create_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::NodeCreateResponse.new()
    plumbing.meta = create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.node = node_to_plumbing(porcelain.node) unless porcelain.node == nil
    plumbing.token = porcelain.token unless porcelain.token == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.node_create_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.node_create_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = NodeCreateResponse.new()
    porcelain.meta = create_response_metadata_to_porcelain(plumbing.meta)
    porcelain.node = node_to_porcelain(plumbing.node)
    porcelain.token = plumbing.token
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.node_delete_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.node_delete_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::NodeDeleteResponse.new()
    plumbing.meta = delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.node_delete_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.node_delete_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = NodeDeleteResponse.new()
    porcelain.meta = delete_response_metadata_to_porcelain(plumbing.meta)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.node_get_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.node_get_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::NodeGetResponse.new()
    plumbing.meta = get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.node = node_to_plumbing(porcelain.node) unless porcelain.node == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.node_get_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.node_get_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = NodeGetResponse.new()
    porcelain.meta = get_response_metadata_to_porcelain(plumbing.meta)
    porcelain.node = node_to_porcelain(plumbing.node)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.node_to_plumbing(porcelain) ⇒ `Object`

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

def self.node_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::Node.new()
    if porcelain .instance_of? Relay
        plumbing.relay = relay_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Gateway
        plumbing.gateway = gateway_to_plumbing(porcelain)
    end
    plumbing
end

.node_to_porcelain(plumbing) ⇒ `Object`

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

def self.node_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    if plumbing.relay != nil
        return relay_to_porcelain(plumbing.relay)
    end
    if plumbing.gateway != nil
        return gateway_to_porcelain(plumbing.gateway)
    end
end

.node_update_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.node_update_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::NodeUpdateResponse.new()
    plumbing.meta = update_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.node = node_to_plumbing(porcelain.node) unless porcelain.node == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.node_update_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.node_update_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = NodeUpdateResponse.new()
    porcelain.meta = update_response_metadata_to_porcelain(plumbing.meta)
    porcelain.node = node_to_porcelain(plumbing.node)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.oracle_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.oracle_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.postgres_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.postgres_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.presto_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.presto_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

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

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

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

.rate_limit_metadata_to_plumbing(porcelain) ⇒ `Object`

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

def self.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 = timestamp_to_plumbing(porcelain.reset_at) unless porcelain.reset_at == nil
    plumbing.bucket = porcelain.bucket unless porcelain.bucket == nil
    plumbing
end

.rate_limit_metadata_to_porcelain(plumbing) ⇒ `Object`

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

def self.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 = timestamp_to_porcelain(plumbing.reset_at)
    porcelain.bucket = plumbing.bucket
    porcelain
end

.rdp_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.rdp_to_porcelain(plumbing) ⇒ `Object`

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

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

.redis_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.redis_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.hostname = plumbing.hostname
    porcelain.port_override = plumbing.port_override
    porcelain.password = plumbing.password
    porcelain.port = plumbing.port
    porcelain
end

.redshift_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.redshift_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.relay_to_plumbing(porcelain) ⇒ `Object`

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

def self.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

.relay_to_porcelain(plumbing) ⇒ `Object`

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

def self.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

.repeated_account_attachment_create_options_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_attachment_create_options_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_attachment_create_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_attachment_create_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_attachment_delete_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_attachment_delete_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_attachment_get_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_attachment_get_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_attachment_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_attachment_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_create_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_create_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_delete_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_delete_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_get_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_get_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_grant_create_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_grant_create_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_grant_delete_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_grant_delete_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_grant_get_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_grant_get_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_grant_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_grant_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_account_update_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_account_update_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_aks_basic_auth_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_aks_basic_auth_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_aks_service_account_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_aks_service_account_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_aks_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_aks_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_amazon_eks_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_amazon_eks_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_amazon_es_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_amazon_es_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_athena_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_athena_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_aurora_mysql_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_aurora_mysql_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_aurora_postgres_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_aurora_postgres_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_big_query_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_big_query_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_cassandra_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_cassandra_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_clustrix_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_clustrix_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_cockroach_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_cockroach_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_create_response_metadata_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_create_response_metadata_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_delete_response_metadata_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_delete_response_metadata_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_druid_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_druid_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_dynamo_db_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_dynamo_db_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_elastic_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_elastic_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_elasticache_redis_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_elasticache_redis_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_gateway_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_gateway_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_get_response_metadata_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_get_response_metadata_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_google_gke_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_google_gke_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_greenplum_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_greenplum_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_http_auth_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_http_auth_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_http_basic_auth_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_http_basic_auth_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_http_no_auth_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_http_no_auth_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_kubernetes_basic_auth_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_kubernetes_basic_auth_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_kubernetes_service_account_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_kubernetes_service_account_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_kubernetes_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_kubernetes_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_maria_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_maria_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_memcached_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_memcached_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_memsql_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_memsql_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_mongo_host_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_mongo_host_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_mongo_legacy_host_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_mongo_legacy_host_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_mongo_legacy_replicaset_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_mongo_legacy_replicaset_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_mongo_replica_set_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_mongo_replica_set_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_mysql_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_mysql_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_node_create_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_node_create_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_node_delete_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_node_delete_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_node_get_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_node_get_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_node_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_node_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_node_update_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_node_update_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_oracle_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_oracle_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_postgres_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_postgres_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_presto_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_presto_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_rate_limit_metadata_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_rate_limit_metadata_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_rdp_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_rdp_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_redis_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_redis_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_redshift_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_redshift_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_relay_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_relay_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_resource_create_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_resource_create_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_resource_delete_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_resource_delete_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_resource_get_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_resource_get_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_resource_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_resource_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_resource_update_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_resource_update_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_attachment_create_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_attachment_create_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_attachment_delete_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_attachment_delete_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_attachment_get_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_attachment_get_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_attachment_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_attachment_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_create_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_create_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_delete_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_delete_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_get_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_get_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_grant_create_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_grant_create_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_grant_delete_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_grant_delete_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_grant_get_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_grant_get_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_grant_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_grant_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_role_update_response_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_role_update_response_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_service_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_service_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_snowflake_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_snowflake_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_sql_server_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_sql_server_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_ssh_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_ssh_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_sybase_iq_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_sybase_iq_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_sybase_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_sybase_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_teradata_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_teradata_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_update_response_metadata_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_update_response_metadata_to_porcelain(plumbings) ⇒ `Object`

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

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

.repeated_user_to_plumbing(porcelains) ⇒ `Object`

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

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

.repeated_user_to_porcelain(plumbings) ⇒ `Object`

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

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

.resource_create_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.resource_create_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::ResourceCreateResponse.new()
    plumbing.meta = create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.resource = resource_to_plumbing(porcelain.resource) unless porcelain.resource == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.resource_create_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.resource_create_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = ResourceCreateResponse.new()
    porcelain.meta = create_response_metadata_to_porcelain(plumbing.meta)
    porcelain.resource = resource_to_porcelain(plumbing.resource)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.resource_delete_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.resource_delete_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::ResourceDeleteResponse.new()
    plumbing.meta = delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.resource_delete_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.resource_delete_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = ResourceDeleteResponse.new()
    porcelain.meta = delete_response_metadata_to_porcelain(plumbing.meta)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.resource_get_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.resource_get_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::ResourceGetResponse.new()
    plumbing.meta = get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.resource = resource_to_plumbing(porcelain.resource) unless porcelain.resource == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.resource_get_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.resource_get_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = ResourceGetResponse.new()
    porcelain.meta = get_response_metadata_to_porcelain(plumbing.meta)
    porcelain.resource = resource_to_porcelain(plumbing.resource)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.resource_to_plumbing(porcelain) ⇒ `Object`

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

def self.resource_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::Resource.new()
    if porcelain .instance_of? Athena
        plumbing.athena = athena_to_plumbing(porcelain)
    end
    if porcelain .instance_of? BigQuery
        plumbing.big_query = big_query_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Cassandra
        plumbing.cassandra = cassandra_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Druid
        plumbing.druid = druid_to_plumbing(porcelain)
    end
    if porcelain .instance_of? DynamoDB
        plumbing.dynamo_db = dynamo_db_to_plumbing(porcelain)
    end
    if porcelain .instance_of? AmazonES
        plumbing.amazon_es = amazon_es_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Elastic
        plumbing.elastic = elastic_to_plumbing(porcelain)
    end
    if porcelain .instance_of? HTTPBasicAuth
        plumbing.http_basic_auth = http_basic_auth_to_plumbing(porcelain)
    end
    if porcelain .instance_of? HTTPNoAuth
        plumbing.http_no_auth = http_no_auth_to_plumbing(porcelain)
    end
    if porcelain .instance_of? HTTPAuth
        plumbing.http_auth = http_auth_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Kubernetes
        plumbing.kubernetes = kubernetes_to_plumbing(porcelain)
    end
    if porcelain .instance_of? KubernetesBasicAuth
        plumbing.kubernetes_basic_auth = kubernetes_basic_auth_to_plumbing(porcelain)
    end
    if porcelain .instance_of? KubernetesServiceAccount
        plumbing.kubernetes_service_account = kubernetes_service_account_to_plumbing(porcelain)
    end
    if porcelain .instance_of? AmazonEKS
        plumbing.amazon_eks = amazon_eks_to_plumbing(porcelain)
    end
    if porcelain .instance_of? GoogleGKE
        plumbing.google_gke = google_gke_to_plumbing(porcelain)
    end
    if porcelain .instance_of? AKS
        plumbing.aks = aks_to_plumbing(porcelain)
    end
    if porcelain .instance_of? AKSBasicAuth
        plumbing.aks_basic_auth = aks_basic_auth_to_plumbing(porcelain)
    end
    if porcelain .instance_of? AKSServiceAccount
        plumbing.aks_service_account = aks_service_account_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Memcached
        plumbing.memcached = memcached_to_plumbing(porcelain)
    end
    if porcelain .instance_of? MongoLegacyHost
        plumbing.mongo_legacy_host = mongo_legacy_host_to_plumbing(porcelain)
    end
    if porcelain .instance_of? MongoLegacyReplicaset
        plumbing.mongo_legacy_replicaset = mongo_legacy_replicaset_to_plumbing(porcelain)
    end
    if porcelain .instance_of? MongoHost
        plumbing.mongo_host = mongo_host_to_plumbing(porcelain)
    end
    if porcelain .instance_of? MongoReplicaSet
        plumbing.mongo_replica_set = mongo_replica_set_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Mysql
        plumbing.mysql = mysql_to_plumbing(porcelain)
    end
    if porcelain .instance_of? AuroraMysql
        plumbing.aurora_mysql = aurora_mysql_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Clustrix
        plumbing.clustrix = clustrix_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Maria
        plumbing.maria = maria_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Memsql
        plumbing.memsql = memsql_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Oracle
        plumbing.oracle = oracle_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Postgres
        plumbing.postgres = postgres_to_plumbing(porcelain)
    end
    if porcelain .instance_of? AuroraPostgres
        plumbing.aurora_postgres = aurora_postgres_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Greenplum
        plumbing.greenplum = greenplum_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Cockroach
        plumbing.cockroach = cockroach_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Redshift
        plumbing.redshift = redshift_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Presto
        plumbing.presto = presto_to_plumbing(porcelain)
    end
    if porcelain .instance_of? RDP
        plumbing.rdp = rdp_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Redis
        plumbing.redis = redis_to_plumbing(porcelain)
    end
    if porcelain .instance_of? ElasticacheRedis
        plumbing.elasticache_redis = elasticache_redis_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Snowflake
        plumbing.snowflake = snowflake_to_plumbing(porcelain)
    end
    if porcelain .instance_of? SQLServer
        plumbing.sql_server = sql_server_to_plumbing(porcelain)
    end
    if porcelain .instance_of? SSH
        plumbing.ssh = ssh_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Sybase
        plumbing.sybase = sybase_to_plumbing(porcelain)
    end
    if porcelain .instance_of? SybaseIQ
        plumbing.sybase_iq = sybase_iq_to_plumbing(porcelain)
    end
    if porcelain .instance_of? Teradata
        plumbing.teradata = teradata_to_plumbing(porcelain)
    end
    plumbing
end

.resource_to_porcelain(plumbing) ⇒ `Object`

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

def self.resource_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    if plumbing.athena != nil
        return athena_to_porcelain(plumbing.athena)
    end
    if plumbing.big_query != nil
        return big_query_to_porcelain(plumbing.big_query)
    end
    if plumbing.cassandra != nil
        return cassandra_to_porcelain(plumbing.cassandra)
    end
    if plumbing.druid != nil
        return druid_to_porcelain(plumbing.druid)
    end
    if plumbing.dynamo_db != nil
        return dynamo_db_to_porcelain(plumbing.dynamo_db)
    end
    if plumbing.amazon_es != nil
        return amazon_es_to_porcelain(plumbing.amazon_es)
    end
    if plumbing.elastic != nil
        return elastic_to_porcelain(plumbing.elastic)
    end
    if plumbing.http_basic_auth != nil
        return http_basic_auth_to_porcelain(plumbing.http_basic_auth)
    end
    if plumbing.http_no_auth != nil
        return http_no_auth_to_porcelain(plumbing.http_no_auth)
    end
    if plumbing.http_auth != nil
        return http_auth_to_porcelain(plumbing.http_auth)
    end
    if plumbing.kubernetes != nil
        return kubernetes_to_porcelain(plumbing.kubernetes)
    end
    if plumbing.kubernetes_basic_auth != nil
        return kubernetes_basic_auth_to_porcelain(plumbing.kubernetes_basic_auth)
    end
    if plumbing.kubernetes_service_account != nil
        return kubernetes_service_account_to_porcelain(plumbing.kubernetes_service_account)
    end
    if plumbing.amazon_eks != nil
        return amazon_eks_to_porcelain(plumbing.amazon_eks)
    end
    if plumbing.google_gke != nil
        return google_gke_to_porcelain(plumbing.google_gke)
    end
    if plumbing.aks != nil
        return aks_to_porcelain(plumbing.aks)
    end
    if plumbing.aks_basic_auth != nil
        return aks_basic_auth_to_porcelain(plumbing.aks_basic_auth)
    end
    if plumbing.aks_service_account != nil
        return aks_service_account_to_porcelain(plumbing.aks_service_account)
    end
    if plumbing.memcached != nil
        return memcached_to_porcelain(plumbing.memcached)
    end
    if plumbing.mongo_legacy_host != nil
        return mongo_legacy_host_to_porcelain(plumbing.mongo_legacy_host)
    end
    if plumbing.mongo_legacy_replicaset != nil
        return mongo_legacy_replicaset_to_porcelain(plumbing.mongo_legacy_replicaset)
    end
    if plumbing.mongo_host != nil
        return mongo_host_to_porcelain(plumbing.mongo_host)
    end
    if plumbing.mongo_replica_set != nil
        return mongo_replica_set_to_porcelain(plumbing.mongo_replica_set)
    end
    if plumbing.mysql != nil
        return mysql_to_porcelain(plumbing.mysql)
    end
    if plumbing.aurora_mysql != nil
        return aurora_mysql_to_porcelain(plumbing.aurora_mysql)
    end
    if plumbing.clustrix != nil
        return clustrix_to_porcelain(plumbing.clustrix)
    end
    if plumbing.maria != nil
        return maria_to_porcelain(plumbing.maria)
    end
    if plumbing.memsql != nil
        return memsql_to_porcelain(plumbing.memsql)
    end
    if plumbing.oracle != nil
        return oracle_to_porcelain(plumbing.oracle)
    end
    if plumbing.postgres != nil
        return postgres_to_porcelain(plumbing.postgres)
    end
    if plumbing.aurora_postgres != nil
        return aurora_postgres_to_porcelain(plumbing.aurora_postgres)
    end
    if plumbing.greenplum != nil
        return greenplum_to_porcelain(plumbing.greenplum)
    end
    if plumbing.cockroach != nil
        return cockroach_to_porcelain(plumbing.cockroach)
    end
    if plumbing.redshift != nil
        return redshift_to_porcelain(plumbing.redshift)
    end
    if plumbing.presto != nil
        return presto_to_porcelain(plumbing.presto)
    end
    if plumbing.rdp != nil
        return rdp_to_porcelain(plumbing.rdp)
    end
    if plumbing.redis != nil
        return redis_to_porcelain(plumbing.redis)
    end
    if plumbing.elasticache_redis != nil
        return elasticache_redis_to_porcelain(plumbing.elasticache_redis)
    end
    if plumbing.snowflake != nil
        return snowflake_to_porcelain(plumbing.snowflake)
    end
    if plumbing.sql_server != nil
        return sql_server_to_porcelain(plumbing.sql_server)
    end
    if plumbing.ssh != nil
        return ssh_to_porcelain(plumbing.ssh)
    end
    if plumbing.sybase != nil
        return sybase_to_porcelain(plumbing.sybase)
    end
    if plumbing.sybase_iq != nil
        return sybase_iq_to_porcelain(plumbing.sybase_iq)
    end
    if plumbing.teradata != nil
        return teradata_to_porcelain(plumbing.teradata)
    end
end

.resource_update_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.resource_update_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::ResourceUpdateResponse.new()
    plumbing.meta = update_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.resource = resource_to_plumbing(porcelain.resource) unless porcelain.resource == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.resource_update_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.resource_update_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = ResourceUpdateResponse.new()
    porcelain.meta = update_response_metadata_to_porcelain(plumbing.meta)
    porcelain.resource = resource_to_porcelain(plumbing.resource)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.role_attachment_create_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.role_attachment_create_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::RoleAttachmentCreateResponse.new()
    plumbing.meta = create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.role_attachment = role_attachment_to_plumbing(porcelain.role_attachment) unless porcelain.role_attachment == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.role_attachment_create_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.role_attachment_create_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = RoleAttachmentCreateResponse.new()
    porcelain.meta = create_response_metadata_to_porcelain(plumbing.meta)
    porcelain.role_attachment = role_attachment_to_porcelain(plumbing.role_attachment)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.role_attachment_delete_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.role_attachment_delete_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::RoleAttachmentDeleteResponse.new()
    plumbing.meta = delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.role_attachment_delete_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.role_attachment_delete_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = RoleAttachmentDeleteResponse.new()
    porcelain.meta = delete_response_metadata_to_porcelain(plumbing.meta)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.role_attachment_get_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.role_attachment_get_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::RoleAttachmentGetResponse.new()
    plumbing.meta = get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.role_attachment = role_attachment_to_plumbing(porcelain.role_attachment) unless porcelain.role_attachment == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.role_attachment_get_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.role_attachment_get_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = RoleAttachmentGetResponse.new()
    porcelain.meta = get_response_metadata_to_porcelain(plumbing.meta)
    porcelain.role_attachment = role_attachment_to_porcelain(plumbing.role_attachment)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.role_attachment_to_plumbing(porcelain) ⇒ `Object`

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

def self.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

.role_attachment_to_porcelain(plumbing) ⇒ `Object`

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

def self.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

.role_create_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.role_create_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::RoleCreateResponse.new()
    plumbing.meta = create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.role = role_to_plumbing(porcelain.role) unless porcelain.role == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.role_create_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.role_create_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = RoleCreateResponse.new()
    porcelain.meta = create_response_metadata_to_porcelain(plumbing.meta)
    porcelain.role = role_to_porcelain(plumbing.role)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.role_delete_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.role_delete_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::RoleDeleteResponse.new()
    plumbing.meta = delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.role_delete_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.role_delete_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = RoleDeleteResponse.new()
    porcelain.meta = delete_response_metadata_to_porcelain(plumbing.meta)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.role_get_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.role_get_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::RoleGetResponse.new()
    plumbing.meta = get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.role = role_to_plumbing(porcelain.role) unless porcelain.role == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.role_get_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.role_get_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = RoleGetResponse.new()
    porcelain.meta = get_response_metadata_to_porcelain(plumbing.meta)
    porcelain.role = role_to_porcelain(plumbing.role)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.role_grant_create_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.role_grant_create_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::RoleGrantCreateResponse.new()
    plumbing.meta = create_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.role_grant = role_grant_to_plumbing(porcelain.role_grant) unless porcelain.role_grant == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.role_grant_create_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.role_grant_create_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = RoleGrantCreateResponse.new()
    porcelain.meta = create_response_metadata_to_porcelain(plumbing.meta)
    porcelain.role_grant = role_grant_to_porcelain(plumbing.role_grant)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.role_grant_delete_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.role_grant_delete_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::RoleGrantDeleteResponse.new()
    plumbing.meta = delete_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.role_grant_delete_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.role_grant_delete_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = RoleGrantDeleteResponse.new()
    porcelain.meta = delete_response_metadata_to_porcelain(plumbing.meta)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.role_grant_get_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.role_grant_get_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::RoleGrantGetResponse.new()
    plumbing.meta = get_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.role_grant = role_grant_to_plumbing(porcelain.role_grant) unless porcelain.role_grant == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.role_grant_get_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.role_grant_get_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = RoleGrantGetResponse.new()
    porcelain.meta = get_response_metadata_to_porcelain(plumbing.meta)
    porcelain.role_grant = role_grant_to_porcelain(plumbing.role_grant)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.role_grant_to_plumbing(porcelain) ⇒ `Object`

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

def self.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

.role_grant_to_porcelain(plumbing) ⇒ `Object`

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

def self.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

.role_to_plumbing(porcelain) ⇒ `Object`

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

def self.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

.role_to_porcelain(plumbing) ⇒ `Object`

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

def self.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

.role_update_response_to_plumbing(porcelain) ⇒ `Object`

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

def self.role_update_response_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::RoleUpdateResponse.new()
    plumbing.meta = update_response_metadata_to_plumbing(porcelain.meta) unless porcelain.meta == nil
    plumbing.role = role_to_plumbing(porcelain.role) unless porcelain.role == nil
    plumbing.rate_limit = rate_limit_metadata_to_plumbing(porcelain.rate_limit) unless porcelain.rate_limit == nil
    plumbing
end

.role_update_response_to_porcelain(plumbing) ⇒ `Object`

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

def self.role_update_response_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = RoleUpdateResponse.new()
    porcelain.meta = update_response_metadata_to_porcelain(plumbing.meta)
    porcelain.role = role_to_porcelain(plumbing.role)
    porcelain.rate_limit = rate_limit_metadata_to_porcelain(plumbing.rate_limit)
    porcelain
end

.service_to_plumbing(porcelain) ⇒ `Object`

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

def self.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

.service_to_porcelain(plumbing) ⇒ `Object`

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

def self.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

.snowflake_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.snowflake_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.sql_server_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.sql_server_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.ssh_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.ssh_to_porcelain(plumbing) ⇒ `Object`

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

def self.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.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

.sybase_iq_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.sybase_iq_to_porcelain(plumbing) ⇒ `Object`

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

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

.sybase_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.sybase_to_porcelain(plumbing) ⇒ `Object`

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

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

.teradata_to_plumbing(porcelain) ⇒ `Object`

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

def self.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.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

.teradata_to_porcelain(plumbing) ⇒ `Object`

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

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

.timestamp_to_plumbing(t) ⇒ `Object`

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

def self.timestamp_to_plumbing(t)
    if t == nil
        return nil
    end
    return Google::Protobuf::Timestamp.new(seconds: t.to_i, nanos: t.nsec)
end

.timestamp_to_porcelain(t) ⇒ `Object`

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

def self.timestamp_to_porcelain(t)
    if t == nil
        return nil
    end
    return Time.at(t.seconds + t.nanos * (10**-9))
end

.update_response_metadata_to_plumbing(porcelain) ⇒ `Object`

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

def self.update_response_metadata_to_plumbing(porcelain)
    if porcelain == nil
        return nil
    end
    plumbing = V1::UpdateResponseMetadata.new()
    plumbing
end

.update_response_metadata_to_porcelain(plumbing) ⇒ `Object`

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

def self.update_response_metadata_to_porcelain(plumbing)
    if plumbing == nil
        return nil
    end
    porcelain = UpdateResponseMetadata.new()
    porcelain
end

.user_to_plumbing(porcelain) ⇒ `Object`

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

def self.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

.user_to_porcelain(plumbing) ⇒ `Object`

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

def self.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

Module: SDM::Plumbing

Class Method Summary collapse

Class Method Details

.account_attachment_create_options_to_plumbing(porcelain) ⇒ Object

.account_attachment_create_options_to_porcelain(plumbing) ⇒ Object

.account_attachment_create_response_to_plumbing(porcelain) ⇒ Object

.account_attachment_create_response_to_porcelain(plumbing) ⇒ Object

.account_attachment_delete_response_to_plumbing(porcelain) ⇒ Object

.account_attachment_delete_response_to_porcelain(plumbing) ⇒ Object

.account_attachment_get_response_to_plumbing(porcelain) ⇒ Object

.account_attachment_get_response_to_porcelain(plumbing) ⇒ Object

.account_attachment_to_plumbing(porcelain) ⇒ Object

.account_attachment_to_porcelain(plumbing) ⇒ Object

.account_create_response_to_plumbing(porcelain) ⇒ Object

.account_create_response_to_porcelain(plumbing) ⇒ Object

.account_delete_response_to_plumbing(porcelain) ⇒ Object

.account_delete_response_to_porcelain(plumbing) ⇒ Object

.account_get_response_to_plumbing(porcelain) ⇒ Object

.account_get_response_to_porcelain(plumbing) ⇒ Object

.account_grant_create_response_to_plumbing(porcelain) ⇒ Object

.account_grant_create_response_to_porcelain(plumbing) ⇒ Object

.account_grant_delete_response_to_plumbing(porcelain) ⇒ Object

.account_grant_delete_response_to_porcelain(plumbing) ⇒ Object

.account_grant_get_response_to_plumbing(porcelain) ⇒ Object

.account_grant_get_response_to_porcelain(plumbing) ⇒ Object

.account_grant_to_plumbing(porcelain) ⇒ Object

.account_grant_to_porcelain(plumbing) ⇒ Object

.account_to_plumbing(porcelain) ⇒ Object

.account_to_porcelain(plumbing) ⇒ Object

.account_update_response_to_plumbing(porcelain) ⇒ Object

.account_update_response_to_porcelain(plumbing) ⇒ Object

.aks_basic_auth_to_plumbing(porcelain) ⇒ Object

.aks_basic_auth_to_porcelain(plumbing) ⇒ Object

.aks_service_account_to_plumbing(porcelain) ⇒ Object

.aks_service_account_to_porcelain(plumbing) ⇒ Object

.aks_to_plumbing(porcelain) ⇒ Object

.aks_to_porcelain(plumbing) ⇒ Object

.amazon_eks_to_plumbing(porcelain) ⇒ Object

.amazon_eks_to_porcelain(plumbing) ⇒ Object

.amazon_es_to_plumbing(porcelain) ⇒ Object

.amazon_es_to_porcelain(plumbing) ⇒ Object

.athena_to_plumbing(porcelain) ⇒ Object

.athena_to_porcelain(plumbing) ⇒ Object

.aurora_mysql_to_plumbing(porcelain) ⇒ Object

.aurora_mysql_to_porcelain(plumbing) ⇒ Object

.aurora_postgres_to_plumbing(porcelain) ⇒ Object

.aurora_postgres_to_porcelain(plumbing) ⇒ Object

.big_query_to_plumbing(porcelain) ⇒ Object

.big_query_to_porcelain(plumbing) ⇒ Object

.cassandra_to_plumbing(porcelain) ⇒ Object

.cassandra_to_porcelain(plumbing) ⇒ Object

.clustrix_to_plumbing(porcelain) ⇒ Object

.clustrix_to_porcelain(plumbing) ⇒ Object

.cockroach_to_plumbing(porcelain) ⇒ Object

.cockroach_to_porcelain(plumbing) ⇒ Object

.create_response_metadata_to_plumbing(porcelain) ⇒ Object

.create_response_metadata_to_porcelain(plumbing) ⇒ Object

.delete_response_metadata_to_plumbing(porcelain) ⇒ Object

.delete_response_metadata_to_porcelain(plumbing) ⇒ Object

.druid_to_plumbing(porcelain) ⇒ Object

.druid_to_porcelain(plumbing) ⇒ Object

.dynamo_db_to_plumbing(porcelain) ⇒ Object

.dynamo_db_to_porcelain(plumbing) ⇒ Object

.elastic_to_plumbing(porcelain) ⇒ Object

.elastic_to_porcelain(plumbing) ⇒ Object

.elasticache_redis_to_plumbing(porcelain) ⇒ Object

.elasticache_redis_to_porcelain(plumbing) ⇒ Object

.error_to_porcelain(err) ⇒ Object

.gateway_to_plumbing(porcelain) ⇒ Object

.gateway_to_porcelain(plumbing) ⇒ Object

.get_response_metadata_to_plumbing(porcelain) ⇒ Object

.get_response_metadata_to_porcelain(plumbing) ⇒ Object

.google_gke_to_plumbing(porcelain) ⇒ Object

.google_gke_to_porcelain(plumbing) ⇒ Object

.greenplum_to_plumbing(porcelain) ⇒ Object

.greenplum_to_porcelain(plumbing) ⇒ Object

.http_auth_to_plumbing(porcelain) ⇒ Object

.http_auth_to_porcelain(plumbing) ⇒ Object

.http_basic_auth_to_plumbing(porcelain) ⇒ Object

.http_basic_auth_to_porcelain(plumbing) ⇒ Object

.account_attachment_create_options_to_plumbing(porcelain) ⇒ `Object`

.account_attachment_create_options_to_porcelain(plumbing) ⇒ `Object`

.account_attachment_create_response_to_plumbing(porcelain) ⇒ `Object`

.account_attachment_create_response_to_porcelain(plumbing) ⇒ `Object`

.account_attachment_delete_response_to_plumbing(porcelain) ⇒ `Object`

.account_attachment_delete_response_to_porcelain(plumbing) ⇒ `Object`

.account_attachment_get_response_to_plumbing(porcelain) ⇒ `Object`

.account_attachment_get_response_to_porcelain(plumbing) ⇒ `Object`

.account_attachment_to_plumbing(porcelain) ⇒ `Object`

.account_attachment_to_porcelain(plumbing) ⇒ `Object`

.account_create_response_to_plumbing(porcelain) ⇒ `Object`

.account_create_response_to_porcelain(plumbing) ⇒ `Object`

.account_delete_response_to_plumbing(porcelain) ⇒ `Object`

.account_delete_response_to_porcelain(plumbing) ⇒ `Object`

.account_get_response_to_plumbing(porcelain) ⇒ `Object`

.account_get_response_to_porcelain(plumbing) ⇒ `Object`

.account_grant_create_response_to_plumbing(porcelain) ⇒ `Object`

.account_grant_create_response_to_porcelain(plumbing) ⇒ `Object`

.account_grant_delete_response_to_plumbing(porcelain) ⇒ `Object`

.account_grant_delete_response_to_porcelain(plumbing) ⇒ `Object`

.account_grant_get_response_to_plumbing(porcelain) ⇒ `Object`

.account_grant_get_response_to_porcelain(plumbing) ⇒ `Object`

.account_grant_to_plumbing(porcelain) ⇒ `Object`

.account_grant_to_porcelain(plumbing) ⇒ `Object`

.account_to_plumbing(porcelain) ⇒ `Object`

.account_to_porcelain(plumbing) ⇒ `Object`

.account_update_response_to_plumbing(porcelain) ⇒ `Object`

.account_update_response_to_porcelain(plumbing) ⇒ `Object`

.aks_basic_auth_to_plumbing(porcelain) ⇒ `Object`

.aks_basic_auth_to_porcelain(plumbing) ⇒ `Object`

.aks_service_account_to_plumbing(porcelain) ⇒ `Object`

.aks_service_account_to_porcelain(plumbing) ⇒ `Object`

.aks_to_plumbing(porcelain) ⇒ `Object`

.aks_to_porcelain(plumbing) ⇒ `Object`

.amazon_eks_to_plumbing(porcelain) ⇒ `Object`

.amazon_eks_to_porcelain(plumbing) ⇒ `Object`

.amazon_es_to_plumbing(porcelain) ⇒ `Object`

.amazon_es_to_porcelain(plumbing) ⇒ `Object`

.athena_to_plumbing(porcelain) ⇒ `Object`

.athena_to_porcelain(plumbing) ⇒ `Object`

.aurora_mysql_to_plumbing(porcelain) ⇒ `Object`

.aurora_mysql_to_porcelain(plumbing) ⇒ `Object`

.aurora_postgres_to_plumbing(porcelain) ⇒ `Object`

.aurora_postgres_to_porcelain(plumbing) ⇒ `Object`

.big_query_to_plumbing(porcelain) ⇒ `Object`

.big_query_to_porcelain(plumbing) ⇒ `Object`

.cassandra_to_plumbing(porcelain) ⇒ `Object`

.cassandra_to_porcelain(plumbing) ⇒ `Object`

.clustrix_to_plumbing(porcelain) ⇒ `Object`

.clustrix_to_porcelain(plumbing) ⇒ `Object`

.cockroach_to_plumbing(porcelain) ⇒ `Object`

.cockroach_to_porcelain(plumbing) ⇒ `Object`

.create_response_metadata_to_plumbing(porcelain) ⇒ `Object`

.create_response_metadata_to_porcelain(plumbing) ⇒ `Object`

.delete_response_metadata_to_plumbing(porcelain) ⇒ `Object`

.delete_response_metadata_to_porcelain(plumbing) ⇒ `Object`

.druid_to_plumbing(porcelain) ⇒ `Object`

.druid_to_porcelain(plumbing) ⇒ `Object`

.dynamo_db_to_plumbing(porcelain) ⇒ `Object`

.dynamo_db_to_porcelain(plumbing) ⇒ `Object`

.elastic_to_plumbing(porcelain) ⇒ `Object`

.elastic_to_porcelain(plumbing) ⇒ `Object`

.elasticache_redis_to_plumbing(porcelain) ⇒ `Object`

.elasticache_redis_to_porcelain(plumbing) ⇒ `Object`

.error_to_porcelain(err) ⇒ `Object`

.gateway_to_plumbing(porcelain) ⇒ `Object`

.gateway_to_porcelain(plumbing) ⇒ `Object`

.get_response_metadata_to_plumbing(porcelain) ⇒ `Object`

.get_response_metadata_to_porcelain(plumbing) ⇒ `Object`

.google_gke_to_plumbing(porcelain) ⇒ `Object`

.google_gke_to_porcelain(plumbing) ⇒ `Object`

.greenplum_to_plumbing(porcelain) ⇒ `Object`

.greenplum_to_porcelain(plumbing) ⇒ `Object`

.http_auth_to_plumbing(porcelain) ⇒ `Object`

.http_auth_to_porcelain(plumbing) ⇒ `Object`

.http_basic_auth_to_plumbing(porcelain) ⇒ `Object`

.http_basic_auth_to_porcelain(plumbing) ⇒ `Object`

.http_no_auth_to_plumbing(porcelain) ⇒ `Object`

.http_no_auth_to_porcelain(plumbing) ⇒ `Object`

.kubernetes_basic_auth_to_plumbing(porcelain) ⇒ `Object`