Artifact Registry v1 API - Class ArtifactRegistryClient (2.6.0)

public abstract class ArtifactRegistryClient

Namespace

Assembly

Google.Cloud.ArtifactRegistry.V1.dll

Remarks

Properties

BatchDeleteVersionsOperationsClient

public virtual OperationsClient BatchDeleteVersionsOperationsClient { get; }

CreateRepositoryOperationsClient

public virtual OperationsClient CreateRepositoryOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeletePackageOperationsClient

public virtual OperationsClient DeletePackageOperationsClient { get; }

DeleteRepositoryOperationsClient

public virtual OperationsClient DeleteRepositoryOperationsClient { get; }

DeleteVersionOperationsClient

public virtual OperationsClient DeleteVersionOperationsClient { get; }

GrpcClient

public virtual ArtifactRegistry.ArtifactRegistryClient GrpcClient { get; }

ImportAptArtifactsOperationsClient

public virtual OperationsClient ImportAptArtifactsOperationsClient { get; }

ImportYumArtifactsOperationsClient

public virtual OperationsClient ImportYumArtifactsOperationsClient { get; }

LocationsClient

public virtual LocationsClient LocationsClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

Methods

BatchDeleteVersions(BatchDeleteVersionsRequest, CallSettings)

public virtual Operation<Empty, BatchDeleteVersionsMetadata> BatchDeleteVersions(BatchDeleteVersionsRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::BatchDeleteVersionsRequest request = new gcav::BatchDeleteVersionsRequest
{
    ParentAsPackageName = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]"),
    VersionNames =
    {
        gcav::VersionName.FromProjectLocationRepositoryPackageVersion("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]", "[VERSION]"),
    },
    ValidateOnly = false,
};
// Make the request
Operation<Empty, gcav::BatchDeleteVersionsMetadata> response = artifactRegistryClient.BatchDeleteVersions(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::BatchDeleteVersionsMetadata> 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, gcav::BatchDeleteVersionsMetadata> retrievedResponse = artifactRegistryClient.PollOnceBatchDeleteVersions(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;
}

BatchDeleteVersions(PackageName, IEnumerable<VersionName>, CallSettings)

public virtual Operation<Empty, BatchDeleteVersionsMetadata> BatchDeleteVersions(PackageName parent, IEnumerable<VersionName> names, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::PackageName parent = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]");
IEnumerable<gcav::VersionName> names = new gcav::VersionName[]
{
    gcav::VersionName.FromProjectLocationRepositoryPackageVersion("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]", "[VERSION]"),
};
// Make the request
Operation<Empty, gcav::BatchDeleteVersionsMetadata> response = artifactRegistryClient.BatchDeleteVersions(parent, names);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::BatchDeleteVersionsMetadata> 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, gcav::BatchDeleteVersionsMetadata> retrievedResponse = artifactRegistryClient.PollOnceBatchDeleteVersions(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;
}

BatchDeleteVersions(string, IEnumerable<string>, CallSettings)

public virtual Operation<Empty, BatchDeleteVersionsMetadata> BatchDeleteVersions(string parent, IEnumerable<string> names, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]";
IEnumerable<string> names = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]/versions/[VERSION]",
};
// Make the request
Operation<Empty, gcav::BatchDeleteVersionsMetadata> response = artifactRegistryClient.BatchDeleteVersions(parent, names);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::BatchDeleteVersionsMetadata> 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, gcav::BatchDeleteVersionsMetadata> retrievedResponse = artifactRegistryClient.PollOnceBatchDeleteVersions(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;
}

BatchDeleteVersionsAsync(BatchDeleteVersionsRequest, CallSettings)

public virtual Task<Operation<Empty, BatchDeleteVersionsMetadata>> BatchDeleteVersionsAsync(BatchDeleteVersionsRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::BatchDeleteVersionsRequest request = new gcav::BatchDeleteVersionsRequest
{
    ParentAsPackageName = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]"),
    VersionNames =
    {
        gcav::VersionName.FromProjectLocationRepositoryPackageVersion("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]", "[VERSION]"),
    },
    ValidateOnly = false,
};
// Make the request
Operation<Empty, gcav::BatchDeleteVersionsMetadata> response = await artifactRegistryClient.BatchDeleteVersionsAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::BatchDeleteVersionsMetadata> 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, gcav::BatchDeleteVersionsMetadata> retrievedResponse = await artifactRegistryClient.PollOnceBatchDeleteVersionsAsync(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;
}

BatchDeleteVersionsAsync(BatchDeleteVersionsRequest, CancellationToken)

public virtual Task<Operation<Empty, BatchDeleteVersionsMetadata>> BatchDeleteVersionsAsync(BatchDeleteVersionsRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::BatchDeleteVersionsRequest request = new gcav::BatchDeleteVersionsRequest
{
    ParentAsPackageName = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]"),
    VersionNames =
    {
        gcav::VersionName.FromProjectLocationRepositoryPackageVersion("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]", "[VERSION]"),
    },
    ValidateOnly = false,
};
// Make the request
Operation<Empty, gcav::BatchDeleteVersionsMetadata> response = await artifactRegistryClient.BatchDeleteVersionsAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::BatchDeleteVersionsMetadata> 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, gcav::BatchDeleteVersionsMetadata> retrievedResponse = await artifactRegistryClient.PollOnceBatchDeleteVersionsAsync(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;
}

BatchDeleteVersionsAsync(PackageName, IEnumerable<VersionName>, CallSettings)

public virtual Task<Operation<Empty, BatchDeleteVersionsMetadata>> BatchDeleteVersionsAsync(PackageName parent, IEnumerable<VersionName> names, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::PackageName parent = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]");
IEnumerable<gcav::VersionName> names = new gcav::VersionName[]
{
    gcav::VersionName.FromProjectLocationRepositoryPackageVersion("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]", "[VERSION]"),
};
// Make the request
Operation<Empty, gcav::BatchDeleteVersionsMetadata> response = await artifactRegistryClient.BatchDeleteVersionsAsync(parent, names);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::BatchDeleteVersionsMetadata> 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, gcav::BatchDeleteVersionsMetadata> retrievedResponse = await artifactRegistryClient.PollOnceBatchDeleteVersionsAsync(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;
}

BatchDeleteVersionsAsync(PackageName, IEnumerable<VersionName>, CancellationToken)

public virtual Task<Operation<Empty, BatchDeleteVersionsMetadata>> BatchDeleteVersionsAsync(PackageName parent, IEnumerable<VersionName> names, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::PackageName parent = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]");
IEnumerable<gcav::VersionName> names = new gcav::VersionName[]
{
    gcav::VersionName.FromProjectLocationRepositoryPackageVersion("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]", "[VERSION]"),
};
// Make the request
Operation<Empty, gcav::BatchDeleteVersionsMetadata> response = await artifactRegistryClient.BatchDeleteVersionsAsync(parent, names);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::BatchDeleteVersionsMetadata> 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, gcav::BatchDeleteVersionsMetadata> retrievedResponse = await artifactRegistryClient.PollOnceBatchDeleteVersionsAsync(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;
}

BatchDeleteVersionsAsync(string, IEnumerable<string>, CallSettings)

public virtual Task<Operation<Empty, BatchDeleteVersionsMetadata>> BatchDeleteVersionsAsync(string parent, IEnumerable<string> names, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]";
IEnumerable<string> names = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]/versions/[VERSION]",
};
// Make the request
Operation<Empty, gcav::BatchDeleteVersionsMetadata> response = await artifactRegistryClient.BatchDeleteVersionsAsync(parent, names);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::BatchDeleteVersionsMetadata> 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, gcav::BatchDeleteVersionsMetadata> retrievedResponse = await artifactRegistryClient.PollOnceBatchDeleteVersionsAsync(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;
}

BatchDeleteVersionsAsync(string, IEnumerable<string>, CancellationToken)

public virtual Task<Operation<Empty, BatchDeleteVersionsMetadata>> BatchDeleteVersionsAsync(string parent, IEnumerable<string> names, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]";
IEnumerable<string> names = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]/versions/[VERSION]",
};
// Make the request
Operation<Empty, gcav::BatchDeleteVersionsMetadata> response = await artifactRegistryClient.BatchDeleteVersionsAsync(parent, names);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::BatchDeleteVersionsMetadata> 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, gcav::BatchDeleteVersionsMetadata> retrievedResponse = await artifactRegistryClient.PollOnceBatchDeleteVersionsAsync(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()

public static ArtifactRegistryClient Create()

CreateAsync(CancellationToken)

public static Task<ArtifactRegistryClient> CreateAsync(CancellationToken cancellationToken = default)

CreateRepository(LocationName, Repository, string, CallSettings)

public virtual Operation<Repository, OperationMetadata> CreateRepository(LocationName parent, Repository repository, string repositoryId, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcav::Repository repository = new gcav::Repository();
string repositoryId = "";
// Make the request
Operation<gcav::Repository, gcav::OperationMetadata> response = artifactRegistryClient.CreateRepository(parent, repository, repositoryId);

// Poll until the returned long-running operation is complete
Operation<gcav::Repository, gcav::OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcav::Repository 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<gcav::Repository, gcav::OperationMetadata> retrievedResponse = artifactRegistryClient.PollOnceCreateRepository(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Repository retrievedResult = retrievedResponse.Result;
}

CreateRepository(CreateRepositoryRequest, CallSettings)

public virtual Operation<Repository, OperationMetadata> CreateRepository(CreateRepositoryRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::CreateRepositoryRequest request = new gcav::CreateRepositoryRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    RepositoryId = "",
    Repository = new gcav::Repository(),
};
// Make the request
Operation<gcav::Repository, gcav::OperationMetadata> response = artifactRegistryClient.CreateRepository(request);

// Poll until the returned long-running operation is complete
Operation<gcav::Repository, gcav::OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcav::Repository 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<gcav::Repository, gcav::OperationMetadata> retrievedResponse = artifactRegistryClient.PollOnceCreateRepository(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Repository retrievedResult = retrievedResponse.Result;
}

CreateRepository(string, Repository, string, CallSettings)

public virtual Operation<Repository, OperationMetadata> CreateRepository(string parent, Repository repository, string repositoryId, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcav::Repository repository = new gcav::Repository();
string repositoryId = "";
// Make the request
Operation<gcav::Repository, gcav::OperationMetadata> response = artifactRegistryClient.CreateRepository(parent, repository, repositoryId);

// Poll until the returned long-running operation is complete
Operation<gcav::Repository, gcav::OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcav::Repository 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<gcav::Repository, gcav::OperationMetadata> retrievedResponse = artifactRegistryClient.PollOnceCreateRepository(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Repository retrievedResult = retrievedResponse.Result;
}

CreateRepositoryAsync(LocationName, Repository, string, CallSettings)

public virtual Task<Operation<Repository, OperationMetadata>> CreateRepositoryAsync(LocationName parent, Repository repository, string repositoryId, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcav::Repository repository = new gcav::Repository();
string repositoryId = "";
// Make the request
Operation<gcav::Repository, gcav::OperationMetadata> response = await artifactRegistryClient.CreateRepositoryAsync(parent, repository, repositoryId);

// Poll until the returned long-running operation is complete
Operation<gcav::Repository, gcav::OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Repository 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<gcav::Repository, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceCreateRepositoryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Repository retrievedResult = retrievedResponse.Result;
}

CreateRepositoryAsync(LocationName, Repository, string, CancellationToken)

public virtual Task<Operation<Repository, OperationMetadata>> CreateRepositoryAsync(LocationName parent, Repository repository, string repositoryId, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcav::Repository repository = new gcav::Repository();
string repositoryId = "";
// Make the request
Operation<gcav::Repository, gcav::OperationMetadata> response = await artifactRegistryClient.CreateRepositoryAsync(parent, repository, repositoryId);

// Poll until the returned long-running operation is complete
Operation<gcav::Repository, gcav::OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Repository 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<gcav::Repository, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceCreateRepositoryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Repository retrievedResult = retrievedResponse.Result;
}

CreateRepositoryAsync(CreateRepositoryRequest, CallSettings)

public virtual Task<Operation<Repository, OperationMetadata>> CreateRepositoryAsync(CreateRepositoryRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::CreateRepositoryRequest request = new gcav::CreateRepositoryRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    RepositoryId = "",
    Repository = new gcav::Repository(),
};
// Make the request
Operation<gcav::Repository, gcav::OperationMetadata> response = await artifactRegistryClient.CreateRepositoryAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcav::Repository, gcav::OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Repository 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<gcav::Repository, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceCreateRepositoryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Repository retrievedResult = retrievedResponse.Result;
}

CreateRepositoryAsync(CreateRepositoryRequest, CancellationToken)

public virtual Task<Operation<Repository, OperationMetadata>> CreateRepositoryAsync(CreateRepositoryRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::CreateRepositoryRequest request = new gcav::CreateRepositoryRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    RepositoryId = "",
    Repository = new gcav::Repository(),
};
// Make the request
Operation<gcav::Repository, gcav::OperationMetadata> response = await artifactRegistryClient.CreateRepositoryAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcav::Repository, gcav::OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Repository 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<gcav::Repository, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceCreateRepositoryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Repository retrievedResult = retrievedResponse.Result;
}

CreateRepositoryAsync(string, Repository, string, CallSettings)

public virtual Task<Operation<Repository, OperationMetadata>> CreateRepositoryAsync(string parent, Repository repository, string repositoryId, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcav::Repository repository = new gcav::Repository();
string repositoryId = "";
// Make the request
Operation<gcav::Repository, gcav::OperationMetadata> response = await artifactRegistryClient.CreateRepositoryAsync(parent, repository, repositoryId);

// Poll until the returned long-running operation is complete
Operation<gcav::Repository, gcav::OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Repository 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<gcav::Repository, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceCreateRepositoryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Repository retrievedResult = retrievedResponse.Result;
}

CreateRepositoryAsync(string, Repository, string, CancellationToken)

public virtual Task<Operation<Repository, OperationMetadata>> CreateRepositoryAsync(string parent, Repository repository, string repositoryId, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcav::Repository repository = new gcav::Repository();
string repositoryId = "";
// Make the request
Operation<gcav::Repository, gcav::OperationMetadata> response = await artifactRegistryClient.CreateRepositoryAsync(parent, repository, repositoryId);

// Poll until the returned long-running operation is complete
Operation<gcav::Repository, gcav::OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Repository 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<gcav::Repository, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceCreateRepositoryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Repository retrievedResult = retrievedResponse.Result;
}

CreateTag(CreateTagRequest, CallSettings)

public virtual Tag CreateTag(CreateTagRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::CreateTagRequest request = new gcav::CreateTagRequest
{
    Parent = "",
    TagId = "",
    Tag = new gcav::Tag(),
};
// Make the request
gcav::Tag response = artifactRegistryClient.CreateTag(request);

CreateTag(string, Tag, string, CallSettings)

public virtual Tag CreateTag(string parent, Tag tag, string tagId, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string parent = "";
gcav::Tag tag = new gcav::Tag();
string tagId = "";
// Make the request
gcav::Tag response = artifactRegistryClient.CreateTag(parent, tag, tagId);

CreateTagAsync(CreateTagRequest, CallSettings)

public virtual Task<Tag> CreateTagAsync(CreateTagRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::CreateTagRequest request = new gcav::CreateTagRequest
{
    Parent = "",
    TagId = "",
    Tag = new gcav::Tag(),
};
// Make the request
gcav::Tag response = await artifactRegistryClient.CreateTagAsync(request);

CreateTagAsync(CreateTagRequest, CancellationToken)

public virtual Task<Tag> CreateTagAsync(CreateTagRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::CreateTagRequest request = new gcav::CreateTagRequest
{
    Parent = "",
    TagId = "",
    Tag = new gcav::Tag(),
};
// Make the request
gcav::Tag response = await artifactRegistryClient.CreateTagAsync(request);

CreateTagAsync(string, Tag, string, CallSettings)

public virtual Task<Tag> CreateTagAsync(string parent, Tag tag, string tagId, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string parent = "";
gcav::Tag tag = new gcav::Tag();
string tagId = "";
// Make the request
gcav::Tag response = await artifactRegistryClient.CreateTagAsync(parent, tag, tagId);

CreateTagAsync(string, Tag, string, CancellationToken)

public virtual Task<Tag> CreateTagAsync(string parent, Tag tag, string tagId, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string parent = "";
gcav::Tag tag = new gcav::Tag();
string tagId = "";
// Make the request
gcav::Tag response = await artifactRegistryClient.CreateTagAsync(parent, tag, tagId);

DeletePackage(DeletePackageRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeletePackage(DeletePackageRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::DeletePackageRequest request = new gcav::DeletePackageRequest
{
    PackageName = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]"),
};
// Make the request
Operation<Empty, gcav::OperationMetadata> response = artifactRegistryClient.DeletePackage(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = artifactRegistryClient.PollOnceDeletePackage(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;
}

DeletePackage(PackageName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeletePackage(PackageName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::PackageName name = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]");
// Make the request
Operation<Empty, gcav::OperationMetadata> response = artifactRegistryClient.DeletePackage(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = artifactRegistryClient.PollOnceDeletePackage(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;
}

DeletePackage(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeletePackage(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]";
// Make the request
Operation<Empty, gcav::OperationMetadata> response = artifactRegistryClient.DeletePackage(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = artifactRegistryClient.PollOnceDeletePackage(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;
}

DeletePackageAsync(DeletePackageRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeletePackageAsync(DeletePackageRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::DeletePackageRequest request = new gcav::DeletePackageRequest
{
    PackageName = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]"),
};
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeletePackageAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeletePackageAsync(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;
}

DeletePackageAsync(DeletePackageRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeletePackageAsync(DeletePackageRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::DeletePackageRequest request = new gcav::DeletePackageRequest
{
    PackageName = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]"),
};
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeletePackageAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeletePackageAsync(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;
}

DeletePackageAsync(PackageName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeletePackageAsync(PackageName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::PackageName name = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]");
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeletePackageAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeletePackageAsync(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;
}

DeletePackageAsync(PackageName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeletePackageAsync(PackageName name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::PackageName name = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]");
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeletePackageAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeletePackageAsync(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;
}

DeletePackageAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeletePackageAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]";
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeletePackageAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeletePackageAsync(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;
}

DeletePackageAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeletePackageAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]";
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeletePackageAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeletePackageAsync(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;
}

DeleteRepository(DeleteRepositoryRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteRepository(DeleteRepositoryRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::DeleteRepositoryRequest request = new gcav::DeleteRepositoryRequest
{
    RepositoryName = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]"),
};
// Make the request
Operation<Empty, gcav::OperationMetadata> response = artifactRegistryClient.DeleteRepository(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = artifactRegistryClient.PollOnceDeleteRepository(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;
}

DeleteRepository(RepositoryName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteRepository(RepositoryName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::RepositoryName name = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]");
// Make the request
Operation<Empty, gcav::OperationMetadata> response = artifactRegistryClient.DeleteRepository(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = artifactRegistryClient.PollOnceDeleteRepository(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;
}

DeleteRepository(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteRepository(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]";
// Make the request
Operation<Empty, gcav::OperationMetadata> response = artifactRegistryClient.DeleteRepository(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = artifactRegistryClient.PollOnceDeleteRepository(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;
}

DeleteRepositoryAsync(DeleteRepositoryRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRepositoryAsync(DeleteRepositoryRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::DeleteRepositoryRequest request = new gcav::DeleteRepositoryRequest
{
    RepositoryName = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]"),
};
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeleteRepositoryAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeleteRepositoryAsync(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;
}

DeleteRepositoryAsync(DeleteRepositoryRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRepositoryAsync(DeleteRepositoryRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::DeleteRepositoryRequest request = new gcav::DeleteRepositoryRequest
{
    RepositoryName = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]"),
};
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeleteRepositoryAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeleteRepositoryAsync(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;
}

DeleteRepositoryAsync(RepositoryName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRepositoryAsync(RepositoryName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::RepositoryName name = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]");
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeleteRepositoryAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeleteRepositoryAsync(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;
}

DeleteRepositoryAsync(RepositoryName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRepositoryAsync(RepositoryName name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::RepositoryName name = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]");
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeleteRepositoryAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeleteRepositoryAsync(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;
}

DeleteRepositoryAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRepositoryAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]";
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeleteRepositoryAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeleteRepositoryAsync(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;
}

DeleteRepositoryAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRepositoryAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]";
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeleteRepositoryAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeleteRepositoryAsync(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;
}

DeleteTag(DeleteTagRequest, CallSettings)

public virtual void DeleteTag(DeleteTagRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::DeleteTagRequest request = new gcav::DeleteTagRequest { Name = "", };
// Make the request
artifactRegistryClient.DeleteTag(request);

DeleteTag(string, CallSettings)

public virtual void DeleteTag(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
artifactRegistryClient.DeleteTag(name);

DeleteTagAsync(DeleteTagRequest, CallSettings)

public virtual Task DeleteTagAsync(DeleteTagRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::DeleteTagRequest request = new gcav::DeleteTagRequest { Name = "", };
// Make the request
await artifactRegistryClient.DeleteTagAsync(request);

DeleteTagAsync(DeleteTagRequest, CancellationToken)

public virtual Task DeleteTagAsync(DeleteTagRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::DeleteTagRequest request = new gcav::DeleteTagRequest { Name = "", };
// Make the request
await artifactRegistryClient.DeleteTagAsync(request);

DeleteTagAsync(string, CallSettings)

public virtual Task DeleteTagAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
await artifactRegistryClient.DeleteTagAsync(name);

DeleteTagAsync(string, CancellationToken)

public virtual Task DeleteTagAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
await artifactRegistryClient.DeleteTagAsync(name);

DeleteVersion(DeleteVersionRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteVersion(DeleteVersionRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::DeleteVersionRequest request = new gcav::DeleteVersionRequest
{
    Name = "",
    Force = false,
};
// Make the request
Operation<Empty, gcav::OperationMetadata> response = artifactRegistryClient.DeleteVersion(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = artifactRegistryClient.PollOnceDeleteVersion(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;
}

DeleteVersion(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteVersion(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Empty, gcav::OperationMetadata> response = artifactRegistryClient.DeleteVersion(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = artifactRegistryClient.PollOnceDeleteVersion(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;
}

DeleteVersionAsync(DeleteVersionRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteVersionAsync(DeleteVersionRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::DeleteVersionRequest request = new gcav::DeleteVersionRequest
{
    Name = "",
    Force = false,
};
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeleteVersionAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeleteVersionAsync(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;
}

DeleteVersionAsync(DeleteVersionRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteVersionAsync(DeleteVersionRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::DeleteVersionRequest request = new gcav::DeleteVersionRequest
{
    Name = "",
    Force = false,
};
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeleteVersionAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeleteVersionAsync(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;
}

DeleteVersionAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteVersionAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeleteVersionAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeleteVersionAsync(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;
}

DeleteVersionAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteVersionAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Empty, gcav::OperationMetadata> response = await artifactRegistryClient.DeleteVersionAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::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, gcav::OperationMetadata> retrievedResponse = await artifactRegistryClient.PollOnceDeleteVersionAsync(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;
}

GetDockerImage(DockerImageName, CallSettings)

public virtual DockerImage GetDockerImage(DockerImageName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::DockerImageName name = gcav::DockerImageName.FromProjectLocationRepositoryDockerImage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[DOCKER_IMAGE]");
// Make the request
gcav::DockerImage response = artifactRegistryClient.GetDockerImage(name);

GetDockerImage(GetDockerImageRequest, CallSettings)

public virtual DockerImage GetDockerImage(GetDockerImageRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::GetDockerImageRequest request = new gcav::GetDockerImageRequest
{
    DockerImageName = gcav::DockerImageName.FromProjectLocationRepositoryDockerImage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[DOCKER_IMAGE]"),
};
// Make the request
gcav::DockerImage response = artifactRegistryClient.GetDockerImage(request);

GetDockerImage(string, CallSettings)

public virtual DockerImage GetDockerImage(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/dockerImages/[DOCKER_IMAGE]";
// Make the request
gcav::DockerImage response = artifactRegistryClient.GetDockerImage(name);

GetDockerImageAsync(DockerImageName, CallSettings)

public virtual Task<DockerImage> GetDockerImageAsync(DockerImageName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::DockerImageName name = gcav::DockerImageName.FromProjectLocationRepositoryDockerImage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[DOCKER_IMAGE]");
// Make the request
gcav::DockerImage response = await artifactRegistryClient.GetDockerImageAsync(name);

GetDockerImageAsync(DockerImageName, CancellationToken)

public virtual Task<DockerImage> GetDockerImageAsync(DockerImageName name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::DockerImageName name = gcav::DockerImageName.FromProjectLocationRepositoryDockerImage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[DOCKER_IMAGE]");
// Make the request
gcav::DockerImage response = await artifactRegistryClient.GetDockerImageAsync(name);

GetDockerImageAsync(GetDockerImageRequest, CallSettings)

public virtual Task<DockerImage> GetDockerImageAsync(GetDockerImageRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetDockerImageRequest request = new gcav::GetDockerImageRequest
{
    DockerImageName = gcav::DockerImageName.FromProjectLocationRepositoryDockerImage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[DOCKER_IMAGE]"),
};
// Make the request
gcav::DockerImage response = await artifactRegistryClient.GetDockerImageAsync(request);

GetDockerImageAsync(GetDockerImageRequest, CancellationToken)

public virtual Task<DockerImage> GetDockerImageAsync(GetDockerImageRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetDockerImageRequest request = new gcav::GetDockerImageRequest
{
    DockerImageName = gcav::DockerImageName.FromProjectLocationRepositoryDockerImage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[DOCKER_IMAGE]"),
};
// Make the request
gcav::DockerImage response = await artifactRegistryClient.GetDockerImageAsync(request);

GetDockerImageAsync(string, CallSettings)

public virtual Task<DockerImage> GetDockerImageAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/dockerImages/[DOCKER_IMAGE]";
// Make the request
gcav::DockerImage response = await artifactRegistryClient.GetDockerImageAsync(name);

GetDockerImageAsync(string, CancellationToken)

public virtual Task<DockerImage> GetDockerImageAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/dockerImages/[DOCKER_IMAGE]";
// Make the request
gcav::DockerImage response = await artifactRegistryClient.GetDockerImageAsync(name);

GetFile(FileName, CallSettings)

public virtual File GetFile(FileName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::FileName name = gcav::FileName.FromProjectLocationRepositoryFile("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[FILE]");
// Make the request
gcav::File response = artifactRegistryClient.GetFile(name);

GetFile(GetFileRequest, CallSettings)

public virtual File GetFile(GetFileRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::GetFileRequest request = new gcav::GetFileRequest
{
    FileName = gcav::FileName.FromProjectLocationRepositoryFile("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[FILE]"),
};
// Make the request
gcav::File response = artifactRegistryClient.GetFile(request);

GetFile(string, CallSettings)

public virtual File GetFile(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/files/[FILE]";
// Make the request
gcav::File response = artifactRegistryClient.GetFile(name);

GetFileAsync(FileName, CallSettings)

public virtual Task<File> GetFileAsync(FileName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::FileName name = gcav::FileName.FromProjectLocationRepositoryFile("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[FILE]");
// Make the request
gcav::File response = await artifactRegistryClient.GetFileAsync(name);

GetFileAsync(FileName, CancellationToken)

public virtual Task<File> GetFileAsync(FileName name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::FileName name = gcav::FileName.FromProjectLocationRepositoryFile("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[FILE]");
// Make the request
gcav::File response = await artifactRegistryClient.GetFileAsync(name);

GetFileAsync(GetFileRequest, CallSettings)

public virtual Task<File> GetFileAsync(GetFileRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetFileRequest request = new gcav::GetFileRequest
{
    FileName = gcav::FileName.FromProjectLocationRepositoryFile("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[FILE]"),
};
// Make the request
gcav::File response = await artifactRegistryClient.GetFileAsync(request);

GetFileAsync(GetFileRequest, CancellationToken)

public virtual Task<File> GetFileAsync(GetFileRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetFileRequest request = new gcav::GetFileRequest
{
    FileName = gcav::FileName.FromProjectLocationRepositoryFile("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[FILE]"),
};
// Make the request
gcav::File response = await artifactRegistryClient.GetFileAsync(request);

GetFileAsync(string, CallSettings)

public virtual Task<File> GetFileAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/files/[FILE]";
// Make the request
gcav::File response = await artifactRegistryClient.GetFileAsync(name);

GetFileAsync(string, CancellationToken)

public virtual Task<File> GetFileAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/files/[FILE]";
// Make the request
gcav::File response = await artifactRegistryClient.GetFileAsync(name);

GetIamPolicy(GetIamPolicyRequest, CallSettings)

public virtual Policy GetIamPolicy(GetIamPolicyRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
GetIamPolicyRequest request = new GetIamPolicyRequest
{
    ResourceAsResourceName = new UnparsedResourceName("a/wildcard/resource"),
    Options = new GetPolicyOptions(),
};
// Make the request
Policy response = artifactRegistryClient.GetIamPolicy(request);

GetIamPolicyAsync(GetIamPolicyRequest, CallSettings)

public virtual Task<Policy> GetIamPolicyAsync(GetIamPolicyRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
GetIamPolicyRequest request = new GetIamPolicyRequest
{
    ResourceAsResourceName = new UnparsedResourceName("a/wildcard/resource"),
    Options = new GetPolicyOptions(),
};
// Make the request
Policy response = await artifactRegistryClient.GetIamPolicyAsync(request);

GetIamPolicyAsync(GetIamPolicyRequest, CancellationToken)

public virtual Task<Policy> GetIamPolicyAsync(GetIamPolicyRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
GetIamPolicyRequest request = new GetIamPolicyRequest
{
    ResourceAsResourceName = new UnparsedResourceName("a/wildcard/resource"),
    Options = new GetPolicyOptions(),
};
// Make the request
Policy response = await artifactRegistryClient.GetIamPolicyAsync(request);

GetMavenArtifact(GetMavenArtifactRequest, CallSettings)

public virtual MavenArtifact GetMavenArtifact(GetMavenArtifactRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::GetMavenArtifactRequest request = new gcav::GetMavenArtifactRequest
{
    MavenArtifactName = gcav::MavenArtifactName.FromProjectLocationRepositoryMavenArtifact("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[MAVEN_ARTIFACT]"),
};
// Make the request
gcav::MavenArtifact response = artifactRegistryClient.GetMavenArtifact(request);

GetMavenArtifact(MavenArtifactName, CallSettings)

public virtual MavenArtifact GetMavenArtifact(MavenArtifactName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::MavenArtifactName name = gcav::MavenArtifactName.FromProjectLocationRepositoryMavenArtifact("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[MAVEN_ARTIFACT]");
// Make the request
gcav::MavenArtifact response = artifactRegistryClient.GetMavenArtifact(name);

GetMavenArtifact(string, CallSettings)

public virtual MavenArtifact GetMavenArtifact(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/mavenArtifacts/[MAVEN_ARTIFACT]";
// Make the request
gcav::MavenArtifact response = artifactRegistryClient.GetMavenArtifact(name);

GetMavenArtifactAsync(GetMavenArtifactRequest, CallSettings)

public virtual Task<MavenArtifact> GetMavenArtifactAsync(GetMavenArtifactRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetMavenArtifactRequest request = new gcav::GetMavenArtifactRequest
{
    MavenArtifactName = gcav::MavenArtifactName.FromProjectLocationRepositoryMavenArtifact("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[MAVEN_ARTIFACT]"),
};
// Make the request
gcav::MavenArtifact response = await artifactRegistryClient.GetMavenArtifactAsync(request);

GetMavenArtifactAsync(GetMavenArtifactRequest, CancellationToken)

public virtual Task<MavenArtifact> GetMavenArtifactAsync(GetMavenArtifactRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetMavenArtifactRequest request = new gcav::GetMavenArtifactRequest
{
    MavenArtifactName = gcav::MavenArtifactName.FromProjectLocationRepositoryMavenArtifact("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[MAVEN_ARTIFACT]"),
};
// Make the request
gcav::MavenArtifact response = await artifactRegistryClient.GetMavenArtifactAsync(request);

GetMavenArtifactAsync(MavenArtifactName, CallSettings)

public virtual Task<MavenArtifact> GetMavenArtifactAsync(MavenArtifactName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::MavenArtifactName name = gcav::MavenArtifactName.FromProjectLocationRepositoryMavenArtifact("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[MAVEN_ARTIFACT]");
// Make the request
gcav::MavenArtifact response = await artifactRegistryClient.GetMavenArtifactAsync(name);

GetMavenArtifactAsync(MavenArtifactName, CancellationToken)

public virtual Task<MavenArtifact> GetMavenArtifactAsync(MavenArtifactName name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::MavenArtifactName name = gcav::MavenArtifactName.FromProjectLocationRepositoryMavenArtifact("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[MAVEN_ARTIFACT]");
// Make the request
gcav::MavenArtifact response = await artifactRegistryClient.GetMavenArtifactAsync(name);

GetMavenArtifactAsync(string, CallSettings)

public virtual Task<MavenArtifact> GetMavenArtifactAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/mavenArtifacts/[MAVEN_ARTIFACT]";
// Make the request
gcav::MavenArtifact response = await artifactRegistryClient.GetMavenArtifactAsync(name);

GetMavenArtifactAsync(string, CancellationToken)

public virtual Task<MavenArtifact> GetMavenArtifactAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/mavenArtifacts/[MAVEN_ARTIFACT]";
// Make the request
gcav::MavenArtifact response = await artifactRegistryClient.GetMavenArtifactAsync(name);

GetNpmPackage(GetNpmPackageRequest, CallSettings)

public virtual NpmPackage GetNpmPackage(GetNpmPackageRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::GetNpmPackageRequest request = new gcav::GetNpmPackageRequest
{
    NpmPackageName = gcav::NpmPackageName.FromProjectLocationRepositoryNpmPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[NPM_PACKAGE]"),
};
// Make the request
gcav::NpmPackage response = artifactRegistryClient.GetNpmPackage(request);

GetNpmPackage(NpmPackageName, CallSettings)

public virtual NpmPackage GetNpmPackage(NpmPackageName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::NpmPackageName name = gcav::NpmPackageName.FromProjectLocationRepositoryNpmPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[NPM_PACKAGE]");
// Make the request
gcav::NpmPackage response = artifactRegistryClient.GetNpmPackage(name);

GetNpmPackage(string, CallSettings)

public virtual NpmPackage GetNpmPackage(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/npmPackages/[NPM_PACKAGE]";
// Make the request
gcav::NpmPackage response = artifactRegistryClient.GetNpmPackage(name);

GetNpmPackageAsync(GetNpmPackageRequest, CallSettings)

public virtual Task<NpmPackage> GetNpmPackageAsync(GetNpmPackageRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetNpmPackageRequest request = new gcav::GetNpmPackageRequest
{
    NpmPackageName = gcav::NpmPackageName.FromProjectLocationRepositoryNpmPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[NPM_PACKAGE]"),
};
// Make the request
gcav::NpmPackage response = await artifactRegistryClient.GetNpmPackageAsync(request);

GetNpmPackageAsync(GetNpmPackageRequest, CancellationToken)

public virtual Task<NpmPackage> GetNpmPackageAsync(GetNpmPackageRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetNpmPackageRequest request = new gcav::GetNpmPackageRequest
{
    NpmPackageName = gcav::NpmPackageName.FromProjectLocationRepositoryNpmPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[NPM_PACKAGE]"),
};
// Make the request
gcav::NpmPackage response = await artifactRegistryClient.GetNpmPackageAsync(request);

GetNpmPackageAsync(NpmPackageName, CallSettings)

public virtual Task<NpmPackage> GetNpmPackageAsync(NpmPackageName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::NpmPackageName name = gcav::NpmPackageName.FromProjectLocationRepositoryNpmPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[NPM_PACKAGE]");
// Make the request
gcav::NpmPackage response = await artifactRegistryClient.GetNpmPackageAsync(name);

GetNpmPackageAsync(NpmPackageName, CancellationToken)

public virtual Task<NpmPackage> GetNpmPackageAsync(NpmPackageName name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::NpmPackageName name = gcav::NpmPackageName.FromProjectLocationRepositoryNpmPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[NPM_PACKAGE]");
// Make the request
gcav::NpmPackage response = await artifactRegistryClient.GetNpmPackageAsync(name);

GetNpmPackageAsync(string, CallSettings)

public virtual Task<NpmPackage> GetNpmPackageAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/npmPackages/[NPM_PACKAGE]";
// Make the request
gcav::NpmPackage response = await artifactRegistryClient.GetNpmPackageAsync(name);

GetNpmPackageAsync(string, CancellationToken)

public virtual Task<NpmPackage> GetNpmPackageAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/npmPackages/[NPM_PACKAGE]";
// Make the request
gcav::NpmPackage response = await artifactRegistryClient.GetNpmPackageAsync(name);

GetPackage(GetPackageRequest, CallSettings)

public virtual Package GetPackage(GetPackageRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::GetPackageRequest request = new gcav::GetPackageRequest
{
    PackageName = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]"),
};
// Make the request
gcav::Package response = artifactRegistryClient.GetPackage(request);

GetPackage(PackageName, CallSettings)

public virtual Package GetPackage(PackageName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::PackageName name = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]");
// Make the request
gcav::Package response = artifactRegistryClient.GetPackage(name);

GetPackage(string, CallSettings)

public virtual Package GetPackage(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]";
// Make the request
gcav::Package response = artifactRegistryClient.GetPackage(name);

GetPackageAsync(GetPackageRequest, CallSettings)

public virtual Task<Package> GetPackageAsync(GetPackageRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetPackageRequest request = new gcav::GetPackageRequest
{
    PackageName = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]"),
};
// Make the request
gcav::Package response = await artifactRegistryClient.GetPackageAsync(request);

GetPackageAsync(GetPackageRequest, CancellationToken)

public virtual Task<Package> GetPackageAsync(GetPackageRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetPackageRequest request = new gcav::GetPackageRequest
{
    PackageName = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]"),
};
// Make the request
gcav::Package response = await artifactRegistryClient.GetPackageAsync(request);

GetPackageAsync(PackageName, CallSettings)

public virtual Task<Package> GetPackageAsync(PackageName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::PackageName name = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]");
// Make the request
gcav::Package response = await artifactRegistryClient.GetPackageAsync(name);

GetPackageAsync(PackageName, CancellationToken)

public virtual Task<Package> GetPackageAsync(PackageName name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::PackageName name = gcav::PackageName.FromProjectLocationRepositoryPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PACKAGE]");
// Make the request
gcav::Package response = await artifactRegistryClient.GetPackageAsync(name);

GetPackageAsync(string, CallSettings)

public virtual Task<Package> GetPackageAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]";
// Make the request
gcav::Package response = await artifactRegistryClient.GetPackageAsync(name);

GetPackageAsync(string, CancellationToken)

public virtual Task<Package> GetPackageAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/packages/[PACKAGE]";
// Make the request
gcav::Package response = await artifactRegistryClient.GetPackageAsync(name);

GetProjectSettings(GetProjectSettingsRequest, CallSettings)

public virtual ProjectSettings GetProjectSettings(GetProjectSettingsRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::GetProjectSettingsRequest request = new gcav::GetProjectSettingsRequest
{
    ProjectSettingsName = gcav::ProjectSettingsName.FromProject("[PROJECT]"),
};
// Make the request
gcav::ProjectSettings response = artifactRegistryClient.GetProjectSettings(request);

GetProjectSettings(ProjectSettingsName, CallSettings)

public virtual ProjectSettings GetProjectSettings(ProjectSettingsName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::ProjectSettingsName name = gcav::ProjectSettingsName.FromProject("[PROJECT]");
// Make the request
gcav::ProjectSettings response = artifactRegistryClient.GetProjectSettings(name);

GetProjectSettings(string, CallSettings)

public virtual ProjectSettings GetProjectSettings(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/projectSettings";
// Make the request
gcav::ProjectSettings response = artifactRegistryClient.GetProjectSettings(name);

GetProjectSettingsAsync(GetProjectSettingsRequest, CallSettings)

public virtual Task<ProjectSettings> GetProjectSettingsAsync(GetProjectSettingsRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetProjectSettingsRequest request = new gcav::GetProjectSettingsRequest
{
    ProjectSettingsName = gcav::ProjectSettingsName.FromProject("[PROJECT]"),
};
// Make the request
gcav::ProjectSettings response = await artifactRegistryClient.GetProjectSettingsAsync(request);

GetProjectSettingsAsync(GetProjectSettingsRequest, CancellationToken)

public virtual Task<ProjectSettings> GetProjectSettingsAsync(GetProjectSettingsRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetProjectSettingsRequest request = new gcav::GetProjectSettingsRequest
{
    ProjectSettingsName = gcav::ProjectSettingsName.FromProject("[PROJECT]"),
};
// Make the request
gcav::ProjectSettings response = await artifactRegistryClient.GetProjectSettingsAsync(request);

GetProjectSettingsAsync(ProjectSettingsName, CallSettings)

public virtual Task<ProjectSettings> GetProjectSettingsAsync(ProjectSettingsName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::ProjectSettingsName name = gcav::ProjectSettingsName.FromProject("[PROJECT]");
// Make the request
gcav::ProjectSettings response = await artifactRegistryClient.GetProjectSettingsAsync(name);

GetProjectSettingsAsync(ProjectSettingsName, CancellationToken)

public virtual Task<ProjectSettings> GetProjectSettingsAsync(ProjectSettingsName name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::ProjectSettingsName name = gcav::ProjectSettingsName.FromProject("[PROJECT]");
// Make the request
gcav::ProjectSettings response = await artifactRegistryClient.GetProjectSettingsAsync(name);

GetProjectSettingsAsync(string, CallSettings)

public virtual Task<ProjectSettings> GetProjectSettingsAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/projectSettings";
// Make the request
gcav::ProjectSettings response = await artifactRegistryClient.GetProjectSettingsAsync(name);

GetProjectSettingsAsync(string, CancellationToken)

public virtual Task<ProjectSettings> GetProjectSettingsAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/projectSettings";
// Make the request
gcav::ProjectSettings response = await artifactRegistryClient.GetProjectSettingsAsync(name);

GetPythonPackage(GetPythonPackageRequest, CallSettings)

public virtual PythonPackage GetPythonPackage(GetPythonPackageRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::GetPythonPackageRequest request = new gcav::GetPythonPackageRequest
{
    PythonPackageName = gcav::PythonPackageName.FromProjectLocationRepositoryPythonPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PYTHON_PACKAGE]"),
};
// Make the request
gcav::PythonPackage response = artifactRegistryClient.GetPythonPackage(request);

GetPythonPackage(PythonPackageName, CallSettings)

public virtual PythonPackage GetPythonPackage(PythonPackageName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::PythonPackageName name = gcav::PythonPackageName.FromProjectLocationRepositoryPythonPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PYTHON_PACKAGE]");
// Make the request
gcav::PythonPackage response = artifactRegistryClient.GetPythonPackage(name);

GetPythonPackage(string, CallSettings)

public virtual PythonPackage GetPythonPackage(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/pythonPackages/[PYTHON_PACKAGE]";
// Make the request
gcav::PythonPackage response = artifactRegistryClient.GetPythonPackage(name);

GetPythonPackageAsync(GetPythonPackageRequest, CallSettings)

public virtual Task<PythonPackage> GetPythonPackageAsync(GetPythonPackageRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetPythonPackageRequest request = new gcav::GetPythonPackageRequest
{
    PythonPackageName = gcav::PythonPackageName.FromProjectLocationRepositoryPythonPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PYTHON_PACKAGE]"),
};
// Make the request
gcav::PythonPackage response = await artifactRegistryClient.GetPythonPackageAsync(request);

GetPythonPackageAsync(GetPythonPackageRequest, CancellationToken)

public virtual Task<PythonPackage> GetPythonPackageAsync(GetPythonPackageRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetPythonPackageRequest request = new gcav::GetPythonPackageRequest
{
    PythonPackageName = gcav::PythonPackageName.FromProjectLocationRepositoryPythonPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PYTHON_PACKAGE]"),
};
// Make the request
gcav::PythonPackage response = await artifactRegistryClient.GetPythonPackageAsync(request);

GetPythonPackageAsync(PythonPackageName, CallSettings)

public virtual Task<PythonPackage> GetPythonPackageAsync(PythonPackageName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::PythonPackageName name = gcav::PythonPackageName.FromProjectLocationRepositoryPythonPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PYTHON_PACKAGE]");
// Make the request
gcav::PythonPackage response = await artifactRegistryClient.GetPythonPackageAsync(name);

GetPythonPackageAsync(PythonPackageName, CancellationToken)

public virtual Task<PythonPackage> GetPythonPackageAsync(PythonPackageName name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::PythonPackageName name = gcav::PythonPackageName.FromProjectLocationRepositoryPythonPackage("[PROJECT]", "[LOCATION]", "[REPOSITORY]", "[PYTHON_PACKAGE]");
// Make the request
gcav::PythonPackage response = await artifactRegistryClient.GetPythonPackageAsync(name);

GetPythonPackageAsync(string, CallSettings)

public virtual Task<PythonPackage> GetPythonPackageAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/pythonPackages/[PYTHON_PACKAGE]";
// Make the request
gcav::PythonPackage response = await artifactRegistryClient.GetPythonPackageAsync(name);

GetPythonPackageAsync(string, CancellationToken)

public virtual Task<PythonPackage> GetPythonPackageAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]/pythonPackages/[PYTHON_PACKAGE]";
// Make the request
gcav::PythonPackage response = await artifactRegistryClient.GetPythonPackageAsync(name);

GetRepository(GetRepositoryRequest, CallSettings)

public virtual Repository GetRepository(GetRepositoryRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::GetRepositoryRequest request = new gcav::GetRepositoryRequest
{
    RepositoryName = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]"),
};
// Make the request
gcav::Repository response = artifactRegistryClient.GetRepository(request);

GetRepository(RepositoryName, CallSettings)

public virtual Repository GetRepository(RepositoryName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::RepositoryName name = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]");
// Make the request
gcav::Repository response = artifactRegistryClient.GetRepository(name);

GetRepository(string, CallSettings)

public virtual Repository GetRepository(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]";
// Make the request
gcav::Repository response = artifactRegistryClient.GetRepository(name);

GetRepositoryAsync(GetRepositoryRequest, CallSettings)

public virtual Task<Repository> GetRepositoryAsync(GetRepositoryRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetRepositoryRequest request = new gcav::GetRepositoryRequest
{
    RepositoryName = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]"),
};
// Make the request
gcav::Repository response = await artifactRegistryClient.GetRepositoryAsync(request);

GetRepositoryAsync(GetRepositoryRequest, CancellationToken)

public virtual Task<Repository> GetRepositoryAsync(GetRepositoryRequest request, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetRepositoryRequest request = new gcav::GetRepositoryRequest
{
    RepositoryName = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]"),
};
// Make the request
gcav::Repository response = await artifactRegistryClient.GetRepositoryAsync(request);

GetRepositoryAsync(RepositoryName, CallSettings)

public virtual Task<Repository> GetRepositoryAsync(RepositoryName name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::RepositoryName name = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]");
// Make the request
gcav::Repository response = await artifactRegistryClient.GetRepositoryAsync(name);

GetRepositoryAsync(RepositoryName, CancellationToken)

public virtual Task<Repository> GetRepositoryAsync(RepositoryName name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::RepositoryName name = gcav::RepositoryName.FromProjectLocationRepository("[PROJECT]", "[LOCATION]", "[REPOSITORY]");
// Make the request
gcav::Repository response = await artifactRegistryClient.GetRepositoryAsync(name);

GetRepositoryAsync(string, CallSettings)

public virtual Task<Repository> GetRepositoryAsync(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]";
// Make the request
gcav::Repository response = await artifactRegistryClient.GetRepositoryAsync(name);

GetRepositoryAsync(string, CancellationToken)

public virtual Task<Repository> GetRepositoryAsync(string name, CancellationToken cancellationToken)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/repositories/[REPOSITORY]";
// Make the request
gcav::Repository response = await artifactRegistryClient.GetRepositoryAsync(name);

GetTag(GetTagRequest, CallSettings)

public virtual Tag GetTag(GetTagRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
gcav::GetTagRequest request = new gcav::GetTagRequest { Name = "", };
// Make the request
gcav::Tag response = artifactRegistryClient.GetTag(request);

GetTag(string, CallSettings)

public virtual Tag GetTag(string name, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = gcav::ArtifactRegistryClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
gcav::Tag response = artifactRegistryClient.GetTag(name);

GetTagAsync(GetTagRequest, CallSettings)

public virtual Task<Tag> GetTagAsync(GetTagRequest request, CallSettings callSettings = null)

// Create client
gcav::ArtifactRegistryClient artifactRegistryClient = await gcav::ArtifactRegistryClient.CreateAsync();
// Initialize request argument(s)
gcav::GetTagRequest request = new gcav::GetTagRequest { Name = "", };
// Make the request
gcav::Tag response = await artifactRegistryClient.GetTagAsync(request);

GetTagAsync(GetTagRequest, CancellationToken)

public virtual Task<Tag> GetTagAsync(GetTagRequest request, CancellationToken cancellationToken)