Cloud Dataplex v1 API - Class CatalogServiceClient (3.0.0)

// 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<gcdv::AspectType, gcdv::OperationMetadata> response = catalogServiceClient.CreateAspectType(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> response = catalogServiceClient.CreateAspectType(request);

// Poll until the returned long-running operation is complete
Operation<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> response = catalogServiceClient.CreateAspectType(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateAspectTypeAsync(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateAspectTypeAsync(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateAspectTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateAspectTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateAspectTypeAsync(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateAspectTypeAsync(parent, aspectType, aspectTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::AspectType, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> response = catalogServiceClient.CreateEntryGroup(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> response = catalogServiceClient.CreateEntryGroup(request);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> response = catalogServiceClient.CreateEntryGroup(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryGroupAsync(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryGroupAsync(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryGroupAsync(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryGroupAsync(parent, entryGroup, entryGroupId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryGroup, gcdv::OperationMetadata> 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<gcdv::EntryGroup, gcdv::OperationMetadata> 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)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::EntryType entryType = new gcdv::EntryType();
string entryTypeId = "";
// Make the request
Operation<gcdv::EntryType, gcdv::OperationMetadata> response = catalogServiceClient.CreateEntryType(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> response = catalogServiceClient.CreateEntryType(request);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> response = catalogServiceClient.CreateEntryType(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryTypeAsync(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryTypeAsync(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryTypeAsync(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> response = await catalogServiceClient.CreateEntryTypeAsync(parent, entryType, entryTypeId);

// Poll until the returned long-running operation is complete
Operation<gcdv::EntryType, gcdv::OperationMetadata> 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<gcdv::EntryType, gcdv::OperationMetadata> 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)
gcdv::AspectTypeName name = gcdv::AspectTypeName.FromProjectLocationAspectType("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = catalogServiceClient.DeleteAspectType(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = catalogServiceClient.DeleteAspectType(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = catalogServiceClient.DeleteAspectType(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteAspectTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteAspectTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteAspectTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteAspectTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteAspectTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteAspectTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = catalogServiceClient.DeleteEntryGroup(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = catalogServiceClient.DeleteEntryGroup(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = catalogServiceClient.DeleteEntryGroup(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryGroupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> 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::DeleteEntryTypeRequest request = new gcdv::DeleteEntryTypeRequest
{
    EntryTypeName = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]"),
    Etag = "",
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = catalogServiceClient.DeleteEntryType(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> retrievedResponse = catalogServiceClient.PollOnceDeleteEntryType(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::EntryTypeName name = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = catalogServiceClient.DeleteEntryType(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> retrievedResponse = catalogServiceClient.PollOnceDeleteEntryType(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]/entryTypes/[ENTRY_TYPE]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = catalogServiceClient.DeleteEntryType(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> retrievedResponse = catalogServiceClient.PollOnceDeleteEntryType(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::DeleteEntryTypeRequest request = new gcdv::DeleteEntryTypeRequest
{
    EntryTypeName = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]"),
    Etag = "",
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryTypeAsync(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::DeleteEntryTypeRequest request = new gcdv::DeleteEntryTypeRequest
{
    EntryTypeName = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]"),
    Etag = "",
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryTypeAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryTypeAsync(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::EntryTypeName name = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryTypeAsync(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::EntryTypeName name = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryTypeAsync(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]/entryTypes/[ENTRY_TYPE]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryTypeAsync(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]/entryTypes/[ENTRY_TYPE]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await catalogServiceClient.DeleteEntryTypeAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcdv::OperationMetadata> 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<Empty, gcdv::OperationMetadata> retrievedResponse = await catalogServiceClient.PollOnceDeleteEntryTypeAsync(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::AspectTypeName name = gcdv::AspectTypeName.FromProjectLocationAspectType("[PROJECT]", "[LOCATION]", "[ASPECT_TYPE]");
// Make the request
gcdv::AspectType response = catalogServiceClient.GetAspectType(name);

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

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

// 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
gcdv::AspectType response = await catalogServiceClient.GetAspectTypeAsync(name);

// 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
gcdv::AspectType response = await catalogServiceClient.GetAspectTypeAsync(name);

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

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

// 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
gcdv::AspectType response = await catalogServiceClient.GetAspectTypeAsync(name);

// 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
gcdv::AspectType response = await catalogServiceClient.GetAspectTypeAsync(name);

// 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.GetEntry(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::GetEntryRequest request = new gcdv::GetEntryRequest
{
    EntryName = gcdv::EntryName.FromProjectLocationEntryGroupEntry("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]"),
    View = gcdv::EntryView.Unspecified,
    AspectTypes = { "", },
    Paths = { "", },
};
// Make the request
gcdv::Entry response = catalogServiceClient.GetEntry(request);

// 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.GetEntry(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.GetEntryAsync(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.GetEntryAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetEntryRequest request = new gcdv::GetEntryRequest
{
    EntryName = gcdv::EntryName.FromProjectLocationEntryGroupEntry("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]"),
    View = gcdv::EntryView.Unspecified,
    AspectTypes = { "", },
    Paths = { "", },
};
// Make the request
gcdv::Entry response = await catalogServiceClient.GetEntryAsync(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetEntryRequest request = new gcdv::GetEntryRequest
{
    EntryName = gcdv::EntryName.FromProjectLocationEntryGroupEntry("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]"),
    View = gcdv::EntryView.Unspecified,
    AspectTypes = { "", },
    Paths = { "", },
};
// Make the request
gcdv::Entry response = await catalogServiceClient.GetEntryAsync(request);

// 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.GetEntryAsync(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.GetEntryAsync(name);

// 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
gcdv::EntryGroup response = catalogServiceClient.GetEntryGroup(name);

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

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

// 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
gcdv::EntryGroup response = await catalogServiceClient.GetEntryGroupAsync(name);

// 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
gcdv::EntryGroup response = await catalogServiceClient.GetEntryGroupAsync(name);

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

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

// 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
gcdv::EntryGroup response = await catalogServiceClient.GetEntryGroupAsync(name);

// 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
gcdv::EntryGroup response = await catalogServiceClient.GetEntryGroupAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::EntryTypeName name = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]");
// Make the request
gcdv::EntryType response = catalogServiceClient.GetEntryType(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::GetEntryTypeRequest request = new gcdv::GetEntryTypeRequest
{
    EntryTypeName = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]"),
};
// Make the request
gcdv::EntryType response = catalogServiceClient.GetEntryType(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entryTypes/[ENTRY_TYPE]";
// Make the request
gcdv::EntryType response = catalogServiceClient.GetEntryType(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EntryTypeName name = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]");
// Make the request
gcdv::EntryType response = await catalogServiceClient.GetEntryTypeAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EntryTypeName name = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]");
// Make the request
gcdv::EntryType response = await catalogServiceClient.GetEntryTypeAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetEntryTypeRequest request = new gcdv::GetEntryTypeRequest
{
    EntryTypeName = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]"),
};
// Make the request
gcdv::EntryType response = await catalogServiceClient.GetEntryTypeAsync(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetEntryTypeRequest request = new gcdv::GetEntryTypeRequest
{
    EntryTypeName = gcdv::EntryTypeName.FromProjectLocationEntryType("[PROJECT]", "[LOCATION]", "[ENTRY_TYPE]"),
};
// Make the request
gcdv::EntryType response = await catalogServiceClient.GetEntryTypeAsync(request);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entryTypes/[ENTRY_TYPE]";
// Make the request
gcdv::EntryType response = await catalogServiceClient.GetEntryTypeAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entryTypes/[ENTRY_TYPE]";
// Make the request
gcdv::EntryType response = await catalogServiceClient.GetEntryTypeAsync(name);

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<gcdv::ListAspectTypesResponse, gcdv::AspectType> response = catalogServiceClient.ListAspectTypes(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (gcdv::AspectType item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (gcdv::ListAspectTypesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (gcdv::AspectType item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::AspectType> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::AspectType item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
gcdv::ListAspectTypesRequest request = new gcdv::ListAspectTypesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<gcdv::ListAspectTypesResponse, gcdv::AspectType> response = catalogServiceClient.ListAspectTypes(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (gcdv::AspectType item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (gcdv::ListAspectTypesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (gcdv::AspectType item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::AspectType> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::AspectType item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
gcdv::CatalogServiceClient catalogServiceClient = gcdv::CatalogServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<gcdv::ListAspectTypesResponse, gcdv::AspectType> response = catalogServiceClient.ListAspectTypes(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (gcdv::AspectType item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (gcdv::ListAspectTypesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (gcdv::AspectType item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::AspectType> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::AspectType item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<gcdv::ListAspectTypesResponse, gcdv::AspectType> response = catalogServiceClient.ListAspectTypesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((gcdv::AspectType item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((gcdv::ListAspectTypesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (gcdv::AspectType item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::AspectType> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::AspectType item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
gcdv::CatalogServiceClient catalogServiceClient = await gcdv::CatalogServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListAspectTypesRequest request = new gcdv::ListAspectTypesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListAspectTypesResponse, gcdv::AspectType> response = catalogServiceClient.ListAspectTypesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((gcdv::AspectType item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((gcdv::ListAspectTypesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (gcdv::AspectType item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::AspectType> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::AspectType item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;