Cloud Dataplex v1 API - Class CatalogServiceClient (3.15.0)

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::CancelMetadataJobRequest request = new gcdv::CancelMetadataJobRequest
{
    MetadataJobName = gcdv::MetadataJobName.FromProjectLocationMetadataJob("[PROJECT]", "[LOCATION]", "[METADATAJOB]"),
};
// Make the request
catalogServiceClient.CancelMetadataJob(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::MetadataJobName name = gcdv::MetadataJobName.FromProjectLocationMetadataJob("[PROJECT]", "[LOCATION]", "[METADATAJOB]");
// Make the request
catalogServiceClient.CancelMetadataJob(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataJobs/[METADATAJOB]";
// Make the request
catalogServiceClient.CancelMetadataJob(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CancelMetadataJobRequest request = new gcdv::CancelMetadataJobRequest
{
    MetadataJobName = gcdv::MetadataJobName.FromProjectLocationMetadataJob("[PROJECT]", "[LOCATION]", "[METADATAJOB]"),
};
// Make the request
await catalogServiceClient.CancelMetadataJobAsync(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CancelMetadataJobRequest request = new gcdv::CancelMetadataJobRequest
{
    MetadataJobName = gcdv::MetadataJobName.FromProjectLocationMetadataJob("[PROJECT]", "[LOCATION]", "[METADATAJOB]"),
};
// Make the request
await catalogServiceClient.CancelMetadataJobAsync(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::MetadataJobName name = gcdv::MetadataJobName.FromProjectLocationMetadataJob("[PROJECT]", "[LOCATION]", "[METADATAJOB]");
// Make the request
await catalogServiceClient.CancelMetadataJobAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::MetadataJobName name = gcdv::MetadataJobName.FromProjectLocationMetadataJob("[PROJECT]", "[LOCATION]", "[METADATAJOB]");
// Make the request
await catalogServiceClient.CancelMetadataJobAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataJobs/[METADATAJOB]";
// Make the request
await catalogServiceClient.CancelMetadataJobAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/metadataJobs/[METADATAJOB]";
// Make the request
await catalogServiceClient.CancelMetadataJobAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::AspectType aspectType = new gcdv::AspectType();
string aspectTypeId = "";
// Make the request
Operation response = catalogServiceClient.CreateAspectType(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::AspectType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateAspectType(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::AspectType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateAspectTypeRequest request = new gcdv::CreateAspectTypeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AspectTypeId = "",
    AspectType = new gcdv::AspectType(),
    ValidateOnly = false,
};
// Make the request
Operation response = catalogServiceClient.CreateAspectType(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::AspectType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateAspectType(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::AspectType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::AspectType aspectType = new gcdv::AspectType();
string aspectTypeId = "";
// Make the request
Operation response = catalogServiceClient.CreateAspectType(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::AspectType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateAspectType(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::AspectType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::AspectType aspectType = new gcdv::AspectType();
string aspectTypeId = "";
// Make the request
Operation response = await catalogServiceClient.CreateAspectTypeAsync(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::AspectType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::AspectType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::AspectType aspectType = new gcdv::AspectType();
string aspectTypeId = "";
// Make the request
Operation response = await catalogServiceClient.CreateAspectTypeAsync(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::AspectType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::AspectType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateAspectTypeRequest request = new gcdv::CreateAspectTypeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AspectTypeId = "",
    AspectType = new gcdv::AspectType(),
    ValidateOnly = false,
};
// Make the request
Operation response = await catalogServiceClient.CreateAspectTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::AspectType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::AspectType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateAspectTypeRequest request = new gcdv::CreateAspectTypeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AspectTypeId = "",
    AspectType = new gcdv::AspectType(),
    ValidateOnly = false,
};
// Make the request
Operation response = await catalogServiceClient.CreateAspectTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::AspectType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::AspectType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::AspectType aspectType = new gcdv::AspectType();
string aspectTypeId = "";
// Make the request
Operation response = await catalogServiceClient.CreateAspectTypeAsync(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::AspectType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::AspectType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::AspectType aspectType = new gcdv::AspectType();
string aspectTypeId = "";
// Make the request
Operation response = await catalogServiceClient.CreateAspectTypeAsync(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::AspectType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::AspectType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateEntryRequest request = new gcdv::CreateEntryRequest
{
    ParentAsEntryGroupName = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]"),
    EntryId = "",
    Entry = new gcdv::Entry(),
};
// Make the request
gcdv::Entry response = catalogServiceClient.CreateEntry(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::EntryGroupName parent = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
gcdv::Entry entry = new gcdv::Entry();
string entryId = "";
// Make the request
gcdv::Entry response = catalogServiceClient.CreateEntry(parent, entry, entryId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]";
gcdv::Entry entry = new gcdv::Entry();
string entryId = "";
// Make the request
gcdv::Entry response = catalogServiceClient.CreateEntry(parent, entry, entryId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateEntryRequest request = new gcdv::CreateEntryRequest
{
    ParentAsEntryGroupName = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]"),
    EntryId = "",
    Entry = new gcdv::Entry(),
};
// Make the request
gcdv::Entry response = await catalogServiceClient.CreateEntryAsync(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateEntryRequest request = new gcdv::CreateEntryRequest
{
    ParentAsEntryGroupName = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]"),
    EntryId = "",
    Entry = new gcdv::Entry(),
};
// Make the request
gcdv::Entry response = await catalogServiceClient.CreateEntryAsync(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EntryGroupName parent = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
gcdv::Entry entry = new gcdv::Entry();
string entryId = "";
// Make the request
gcdv::Entry response = await catalogServiceClient.CreateEntryAsync(parent, entry, entryId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EntryGroupName parent = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
gcdv::Entry entry = new gcdv::Entry();
string entryId = "";
// Make the request
gcdv::Entry response = await catalogServiceClient.CreateEntryAsync(parent, entry, entryId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]";
gcdv::Entry entry = new gcdv::Entry();
string entryId = "";
// Make the request
gcdv::Entry response = await catalogServiceClient.CreateEntryAsync(parent, entry, entryId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]";
gcdv::Entry entry = new gcdv::Entry();
string entryId = "";
// Make the request
gcdv::Entry response = await catalogServiceClient.CreateEntryAsync(parent, entry, entryId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::EntryGroup entryGroup = new gcdv::EntryGroup();
string entryGroupId = "";
// Make the request
Operation response = catalogServiceClient.CreateEntryGroup(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::EntryGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateEntryGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryGroup retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateEntryGroupRequest request = new gcdv::CreateEntryGroupRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    EntryGroupId = "",
    EntryGroup = new gcdv::EntryGroup(),
    ValidateOnly = false,
};
// Make the request
Operation response = catalogServiceClient.CreateEntryGroup(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::EntryGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateEntryGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryGroup retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::EntryGroup entryGroup = new gcdv::EntryGroup();
string entryGroupId = "";
// Make the request
Operation response = catalogServiceClient.CreateEntryGroup(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::EntryGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateEntryGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryGroup retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::EntryGroup entryGroup = new gcdv::EntryGroup();
string entryGroupId = "";
// Make the request
Operation response = await catalogServiceClient.CreateEntryGroupAsync(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryGroup retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::EntryGroup entryGroup = new gcdv::EntryGroup();
string entryGroupId = "";
// Make the request
Operation response = await catalogServiceClient.CreateEntryGroupAsync(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryGroup retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateEntryGroupRequest request = new gcdv::CreateEntryGroupRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    EntryGroupId = "",
    EntryGroup = new gcdv::EntryGroup(),
    ValidateOnly = false,
};
// Make the request
Operation response = await catalogServiceClient.CreateEntryGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryGroup retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateEntryGroupRequest request = new gcdv::CreateEntryGroupRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    EntryGroupId = "",
    EntryGroup = new gcdv::EntryGroup(),
    ValidateOnly = false,
};
// Make the request
Operation response = await catalogServiceClient.CreateEntryGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryGroup retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::EntryGroup entryGroup = new gcdv::EntryGroup();
string entryGroupId = "";
// Make the request
Operation response = await catalogServiceClient.CreateEntryGroupAsync(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryGroup retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::EntryGroup entryGroup = new gcdv::EntryGroup();
string entryGroupId = "";
// Make the request
Operation response = await catalogServiceClient.CreateEntryGroupAsync(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryGroup result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryGroup retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateEntryLinkRequest request = new gcdv::CreateEntryLinkRequest
{
    ParentAsEntryGroupName = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]"),
    EntryLinkId = "",
    EntryLink = new gcdv::EntryLink(),
};
// Make the request
gcdv::EntryLink response = catalogServiceClient.CreateEntryLink(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::EntryGroupName parent = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
gcdv::EntryLink entryLink = new gcdv::EntryLink();
string entryLinkId = "";
// Make the request
gcdv::EntryLink response = catalogServiceClient.CreateEntryLink(parent, entryLink, entryLinkId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]";
gcdv::EntryLink entryLink = new gcdv::EntryLink();
string entryLinkId = "";
// Make the request
gcdv::EntryLink response = catalogServiceClient.CreateEntryLink(parent, entryLink, entryLinkId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateEntryLinkRequest request = new gcdv::CreateEntryLinkRequest
{
    ParentAsEntryGroupName = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]"),
    EntryLinkId = "",
    EntryLink = new gcdv::EntryLink(),
};
// Make the request
gcdv::EntryLink response = await catalogServiceClient.CreateEntryLinkAsync(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateEntryLinkRequest request = new gcdv::CreateEntryLinkRequest
{
    ParentAsEntryGroupName = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]"),
    EntryLinkId = "",
    EntryLink = new gcdv::EntryLink(),
};
// Make the request
gcdv::EntryLink response = await catalogServiceClient.CreateEntryLinkAsync(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EntryGroupName parent = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
gcdv::EntryLink entryLink = new gcdv::EntryLink();
string entryLinkId = "";
// Make the request
gcdv::EntryLink response = await catalogServiceClient.CreateEntryLinkAsync(parent, entryLink, entryLinkId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EntryGroupName parent = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
gcdv::EntryLink entryLink = new gcdv::EntryLink();
string entryLinkId = "";
// Make the request
gcdv::EntryLink response = await catalogServiceClient.CreateEntryLinkAsync(parent, entryLink, entryLinkId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]";
gcdv::EntryLink entryLink = new gcdv::EntryLink();
string entryLinkId = "";
// Make the request
gcdv::EntryLink response = await catalogServiceClient.CreateEntryLinkAsync(parent, entryLink, entryLinkId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]";
gcdv::EntryLink entryLink = new gcdv::EntryLink();
string entryLinkId = "";
// Make the request
gcdv::EntryLink response = await catalogServiceClient.CreateEntryLinkAsync(parent, entryLink, entryLinkId);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::EntryType entryType = new gcdv::EntryType();
string entryTypeId = "";
// Make the request
Operation response = catalogServiceClient.CreateEntryType(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::EntryType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateEntryType(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateEntryTypeRequest request = new gcdv::CreateEntryTypeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    EntryTypeId = "",
    EntryType = new gcdv::EntryType(),
    ValidateOnly = false,
};
// Make the request
Operation response = catalogServiceClient.CreateEntryType(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::EntryType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateEntryType(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::EntryType entryType = new gcdv::EntryType();
string entryTypeId = "";
// Make the request
Operation response = catalogServiceClient.CreateEntryType(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::EntryType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateEntryType(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::EntryType entryType = new gcdv::EntryType();
string entryTypeId = "";
// Make the request
Operation response = await catalogServiceClient.CreateEntryTypeAsync(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::EntryType entryType = new gcdv::EntryType();
string entryTypeId = "";
// Make the request
Operation response = await catalogServiceClient.CreateEntryTypeAsync(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateEntryTypeRequest request = new gcdv::CreateEntryTypeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    EntryTypeId = "",
    EntryType = new gcdv::EntryType(),
    ValidateOnly = false,
};
// Make the request
Operation response = await catalogServiceClient.CreateEntryTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateEntryTypeRequest request = new gcdv::CreateEntryTypeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    EntryTypeId = "",
    EntryType = new gcdv::EntryType(),
    ValidateOnly = false,
};
// Make the request
Operation response = await catalogServiceClient.CreateEntryTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::EntryType entryType = new gcdv::EntryType();
string entryTypeId = "";
// Make the request
Operation response = await catalogServiceClient.CreateEntryTypeAsync(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::EntryType entryType = new gcdv::EntryType();
string entryTypeId = "";
// Make the request
Operation response = await catalogServiceClient.CreateEntryTypeAsync(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::EntryType result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateEntryTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::EntryType retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::MetadataFeed metadataFeed = new gcdv::MetadataFeed();
string metadataFeedId = "";
// Make the request
Operation response = catalogServiceClient.CreateMetadataFeed(parent, metadataFeed, metadataFeedId);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::MetadataFeed result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateMetadataFeed(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataFeed retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateMetadataFeedRequest request = new gcdv::CreateMetadataFeedRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MetadataFeed = new gcdv::MetadataFeed(),
    MetadataFeedId = "",
    ValidateOnly = false,
};
// Make the request
Operation response = catalogServiceClient.CreateMetadataFeed(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::MetadataFeed result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateMetadataFeed(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataFeed retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::MetadataFeed metadataFeed = new gcdv::MetadataFeed();
string metadataFeedId = "";
// Make the request
Operation response = catalogServiceClient.CreateMetadataFeed(parent, metadataFeed, metadataFeedId);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::MetadataFeed result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateMetadataFeed(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataFeed retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::MetadataFeed metadataFeed = new gcdv::MetadataFeed();
string metadataFeedId = "";
// Make the request
Operation response = await catalogServiceClient.CreateMetadataFeedAsync(parent, metadataFeed, metadataFeedId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataFeed result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataFeedAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataFeed retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::MetadataFeed metadataFeed = new gcdv::MetadataFeed();
string metadataFeedId = "";
// Make the request
Operation response = await catalogServiceClient.CreateMetadataFeedAsync(parent, metadataFeed, metadataFeedId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataFeed result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataFeedAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataFeed retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateMetadataFeedRequest request = new gcdv::CreateMetadataFeedRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MetadataFeed = new gcdv::MetadataFeed(),
    MetadataFeedId = "",
    ValidateOnly = false,
};
// Make the request
Operation response = await catalogServiceClient.CreateMetadataFeedAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataFeed result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataFeedAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataFeed retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateMetadataFeedRequest request = new gcdv::CreateMetadataFeedRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MetadataFeed = new gcdv::MetadataFeed(),
    MetadataFeedId = "",
    ValidateOnly = false,
};
// Make the request
Operation response = await catalogServiceClient.CreateMetadataFeedAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataFeed result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataFeedAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataFeed retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::MetadataFeed metadataFeed = new gcdv::MetadataFeed();
string metadataFeedId = "";
// Make the request
Operation response = await catalogServiceClient.CreateMetadataFeedAsync(parent, metadataFeed, metadataFeedId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataFeed result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataFeedAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataFeed retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::MetadataFeed metadataFeed = new gcdv::MetadataFeed();
string metadataFeedId = "";
// Make the request
Operation response = await catalogServiceClient.CreateMetadataFeedAsync(parent, metadataFeed, metadataFeedId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataFeed result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataFeedAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataFeed retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::MetadataJob metadataJob = new gcdv::MetadataJob();
string metadataJobId = "";
// Make the request
Operation response = catalogServiceClient.CreateMetadataJob(parent, metadataJob, metadataJobId);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::MetadataJob result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateMetadataJob(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataJob retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateMetadataJobRequest request = new gcdv::CreateMetadataJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MetadataJob = new gcdv::MetadataJob(),
    MetadataJobId = "",
    ValidateOnly = false,
};
// Make the request
Operation response = catalogServiceClient.CreateMetadataJob(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::MetadataJob result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateMetadataJob(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataJob retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::MetadataJob metadataJob = new gcdv::MetadataJob();
string metadataJobId = "";
// Make the request
Operation response = catalogServiceClient.CreateMetadataJob(parent, metadataJob, metadataJobId);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcdv::MetadataJob result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceCreateMetadataJob(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataJob retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::MetadataJob metadataJob = new gcdv::MetadataJob();
string metadataJobId = "";
// Make the request
Operation response = await catalogServiceClient.CreateMetadataJobAsync(parent, metadataJob, metadataJobId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataJob result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataJob retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::MetadataJob metadataJob = new gcdv::MetadataJob();
string metadataJobId = "";
// Make the request
Operation response = await catalogServiceClient.CreateMetadataJobAsync(parent, metadataJob, metadataJobId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataJob result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataJob retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateMetadataJobRequest request = new gcdv::CreateMetadataJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MetadataJob = new gcdv::MetadataJob(),
    MetadataJobId = "",
    ValidateOnly = false,
};
// Make the request
Operation response = await catalogServiceClient.CreateMetadataJobAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataJob result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataJob retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateMetadataJobRequest request = new gcdv::CreateMetadataJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MetadataJob = new gcdv::MetadataJob(),
    MetadataJobId = "",
    ValidateOnly = false,
};
// Make the request
Operation response = await catalogServiceClient.CreateMetadataJobAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataJob result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataJob retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::MetadataJob metadataJob = new gcdv::MetadataJob();
string metadataJobId = "";
// Make the request
Operation response = await catalogServiceClient.CreateMetadataJobAsync(parent, metadataJob, metadataJobId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataJob result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataJob retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::MetadataJob metadataJob = new gcdv::MetadataJob();
string metadataJobId = "";
// Make the request
Operation response = await catalogServiceClient.CreateMetadataJobAsync(parent, metadataJob, metadataJobId);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcdv::MetadataJob result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceCreateMetadataJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::MetadataJob retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::AspectTypeName name = gcdv::AspectTypeName.FromProjectLocationAspectType("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]");
// Make the request
Operation response = catalogServiceClient.DeleteAspectType(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceDeleteAspectType(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteAspectTypeRequest request = new gcdv::DeleteAspectTypeRequest
{
    AspectTypeName = gcdv::AspectTypeName.FromProjectLocationAspectType("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]"),
    Etag = "",
};
// Make the request
Operation response = catalogServiceClient.DeleteAspectType(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceDeleteAspectType(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aspectTypes/[ASPECT_TYPE]";
// Make the request
Operation response = catalogServiceClient.DeleteAspectType(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceDeleteAspectType(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::AspectTypeName name = gcdv::AspectTypeName.FromProjectLocationAspectType("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]");
// Make the request
Operation response = await catalogServiceClient.DeleteAspectTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::AspectTypeName name = gcdv::AspectTypeName.FromProjectLocationAspectType("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]");
// Make the request
Operation response = await catalogServiceClient.DeleteAspectTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteAspectTypeRequest request = new gcdv::DeleteAspectTypeRequest
{
    AspectTypeName = gcdv::AspectTypeName.FromProjectLocationAspectType("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]"),
    Etag = "",
};
// Make the request
Operation response = await catalogServiceClient.DeleteAspectTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteAspectTypeRequest request = new gcdv::DeleteAspectTypeRequest
{
    AspectTypeName = gcdv::AspectTypeName.FromProjectLocationAspectType("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]"),
    Etag = "",
};
// Make the request
Operation response = await catalogServiceClient.DeleteAspectTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aspectTypes/[ASPECT_TYPE]";
// Make the request
Operation response = await catalogServiceClient.DeleteAspectTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aspectTypes/[ASPECT_TYPE]";
// Make the request
Operation response = await catalogServiceClient.DeleteAspectTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteAspectTypeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteEntryRequest request = new gcdv::DeleteEntryRequest
{
    EntryName = gcdv::EntryName.FromProjectLocationEntryGroupEntry("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]"),
};
// Make the request
gcdv::Entry response = catalogServiceClient.DeleteEntry(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::EntryName name = gcdv::EntryName.FromProjectLocationEntryGroupEntry("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
// Make the request
gcdv::Entry response = catalogServiceClient.DeleteEntry(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]/entries/[ENTRY]";
// Make the request
gcdv::Entry response = catalogServiceClient.DeleteEntry(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteEntryRequest request = new gcdv::DeleteEntryRequest
{
    EntryName = gcdv::EntryName.FromProjectLocationEntryGroupEntry("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]"),
};
// Make the request
gcdv::Entry response = await catalogServiceClient.DeleteEntryAsync(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteEntryRequest request = new gcdv::DeleteEntryRequest
{
    EntryName = gcdv::EntryName.FromProjectLocationEntryGroupEntry("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]"),
};
// Make the request
gcdv::Entry response = await catalogServiceClient.DeleteEntryAsync(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EntryName name = gcdv::EntryName.FromProjectLocationEntryGroupEntry("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
// Make the request
gcdv::Entry response = await catalogServiceClient.DeleteEntryAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EntryName name = gcdv::EntryName.FromProjectLocationEntryGroupEntry("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]");
// Make the request
gcdv::Entry response = await catalogServiceClient.DeleteEntryAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]/entries/[ENTRY]";
// Make the request
gcdv::Entry response = await catalogServiceClient.DeleteEntryAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]/entries/[ENTRY]";
// Make the request
gcdv::Entry response = await catalogServiceClient.DeleteEntryAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteEntryGroupRequest request = new gcdv::DeleteEntryGroupRequest
{
    EntryGroupName = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]"),
    Etag = "",
};
// Make the request
Operation response = catalogServiceClient.DeleteEntryGroup(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceDeleteEntryGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::EntryGroupName name = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
// Make the request
Operation response = catalogServiceClient.DeleteEntryGroup(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceDeleteEntryGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]";
// Make the request
Operation response = catalogServiceClient.DeleteEntryGroup(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = catalogServiceClient.PollOnceDeleteEntryGroup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteEntryGroupRequest request = new gcdv::DeleteEntryGroupRequest
{
    EntryGroupName = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]"),
    Etag = "",
};
// Make the request
Operation response = await catalogServiceClient.DeleteEntryGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteEntryGroupRequest request = new gcdv::DeleteEntryGroupRequest
{
    EntryGroupName = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]"),
    Etag = "",
};
// Make the request
Operation response = await catalogServiceClient.DeleteEntryGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EntryGroupName name = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
// Make the request
Operation response = await catalogServiceClient.DeleteEntryGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EntryGroupName name = gcdv::EntryGroupName.FromProjectLocationEntryGroup("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]");
// Make the request
Operation response = await catalogServiceClient.DeleteEntryGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]";
// Make the request
Operation response = await catalogServiceClient.DeleteEntryGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]";
// Make the request
Operation response = await catalogServiceClient.DeleteEntryGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryGroupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteEntryLinkRequest request = new gcdv::DeleteEntryLinkRequest
{
    EntryLinkName = gcdv::EntryLinkName.FromProjectLocationEntryGroupEntryLink("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY_LINK]"),
};
// Make the request
gcdv::EntryLink response = catalogServiceClient.DeleteEntryLink(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::EntryLinkName name = gcdv::EntryLinkName.FromProjectLocationEntryGroupEntryLink("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY_LINK]");
// Make the request
gcdv::EntryLink response = catalogServiceClient.DeleteEntryLink(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]/entryLinks/[ENTRY_LINK]";
// Make the request
gcdv::EntryLink response = catalogServiceClient.DeleteEntryLink(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteEntryLinkRequest request = new gcdv::DeleteEntryLinkRequest
{
    EntryLinkName = gcdv::EntryLinkName.FromProjectLocationEntryGroupEntryLink("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY_LINK]"),
};
// Make the request
gcdv::EntryLink response = await catalogServiceClient.DeleteEntryLinkAsync(request);