Cloud AI Platform v1beta1 API - Class VertexRagDataServiceClient (1.0.0-beta08)

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
RagCorpus ragCorpus = new RagCorpus();
// Make the request
Operation<RagCorpus, CreateRagCorpusOperationMetadata> response = vertexRagDataServiceClient.CreateRagCorpus(parent, ragCorpus);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
CreateRagCorpusRequest request = new CreateRagCorpusRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    RagCorpus = new RagCorpus(),
};
// Make the request
Operation<RagCorpus, CreateRagCorpusOperationMetadata> response = vertexRagDataServiceClient.CreateRagCorpus(request);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
RagCorpus ragCorpus = new RagCorpus();
// Make the request
Operation<RagCorpus, CreateRagCorpusOperationMetadata> response = vertexRagDataServiceClient.CreateRagCorpus(parent, ragCorpus);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
RagCorpus ragCorpus = new RagCorpus();
// Make the request
Operation<RagCorpus, CreateRagCorpusOperationMetadata> response = await vertexRagDataServiceClient.CreateRagCorpusAsync(parent, ragCorpus);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
RagCorpus ragCorpus = new RagCorpus();
// Make the request
Operation<RagCorpus, CreateRagCorpusOperationMetadata> response = await vertexRagDataServiceClient.CreateRagCorpusAsync(parent, ragCorpus);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateRagCorpusRequest request = new CreateRagCorpusRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    RagCorpus = new RagCorpus(),
};
// Make the request
Operation<RagCorpus, CreateRagCorpusOperationMetadata> response = await vertexRagDataServiceClient.CreateRagCorpusAsync(request);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
CreateRagCorpusRequest request = new CreateRagCorpusRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    RagCorpus = new RagCorpus(),
};
// Make the request
Operation<RagCorpus, CreateRagCorpusOperationMetadata> response = await vertexRagDataServiceClient.CreateRagCorpusAsync(request);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
RagCorpus ragCorpus = new RagCorpus();
// Make the request
Operation<RagCorpus, CreateRagCorpusOperationMetadata> response = await vertexRagDataServiceClient.CreateRagCorpusAsync(parent, ragCorpus);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
RagCorpus ragCorpus = new RagCorpus();
// Make the request
Operation<RagCorpus, CreateRagCorpusOperationMetadata> response = await vertexRagDataServiceClient.CreateRagCorpusAsync(parent, ragCorpus);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
DeleteRagCorpusRequest request = new DeleteRagCorpusRequest
{
    RagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = vertexRagDataServiceClient.DeleteRagCorpus(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = vertexRagDataServiceClient.PollOnceDeleteRagCorpus(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
RagCorpusName name = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = vertexRagDataServiceClient.DeleteRagCorpus(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = vertexRagDataServiceClient.PollOnceDeleteRagCorpus(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = vertexRagDataServiceClient.DeleteRagCorpus(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = vertexRagDataServiceClient.PollOnceDeleteRagCorpus(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteRagCorpusRequest request = new DeleteRagCorpusRequest
{
    RagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagCorpusAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagCorpusAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteRagCorpusRequest request = new DeleteRagCorpusRequest
{
    RagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagCorpusAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagCorpusAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagCorpusName name = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagCorpusAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagCorpusAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagCorpusName name = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagCorpusAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagCorpusAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagCorpusAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagCorpusAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagCorpusAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagCorpusAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
DeleteRagFileRequest request = new DeleteRagFileRequest
{
    RagFileName = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = vertexRagDataServiceClient.DeleteRagFile(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = vertexRagDataServiceClient.PollOnceDeleteRagFile(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
RagFileName name = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = vertexRagDataServiceClient.DeleteRagFile(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = vertexRagDataServiceClient.PollOnceDeleteRagFile(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]/ragFiles/[RAG_FILE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = vertexRagDataServiceClient.DeleteRagFile(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = vertexRagDataServiceClient.PollOnceDeleteRagFile(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteRagFileRequest request = new DeleteRagFileRequest
{
    RagFileName = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagFileAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagFileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteRagFileRequest request = new DeleteRagFileRequest
{
    RagFileName = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagFileAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagFileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagFileName name = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagFileAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagFileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagFileName name = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagFileAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagFileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]/ragFiles/[RAG_FILE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagFileAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagFileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]/ragFiles/[RAG_FILE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await vertexRagDataServiceClient.DeleteRagFileAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await vertexRagDataServiceClient.PollOnceDeleteRagFileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
GetRagCorpusRequest request = new GetRagCorpusRequest
{
    RagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
};
// Make the request
RagCorpus response = vertexRagDataServiceClient.GetRagCorpus(request);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
RagCorpusName name = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
// Make the request
RagCorpus response = vertexRagDataServiceClient.GetRagCorpus(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
// Make the request
RagCorpus response = vertexRagDataServiceClient.GetRagCorpus(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
GetRagCorpusRequest request = new GetRagCorpusRequest
{
    RagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
};
// Make the request
RagCorpus response = await vertexRagDataServiceClient.GetRagCorpusAsync(request);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
GetRagCorpusRequest request = new GetRagCorpusRequest
{
    RagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
};
// Make the request
RagCorpus response = await vertexRagDataServiceClient.GetRagCorpusAsync(request);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagCorpusName name = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
// Make the request
RagCorpus response = await vertexRagDataServiceClient.GetRagCorpusAsync(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagCorpusName name = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
// Make the request
RagCorpus response = await vertexRagDataServiceClient.GetRagCorpusAsync(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
// Make the request
RagCorpus response = await vertexRagDataServiceClient.GetRagCorpusAsync(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
// Make the request
RagCorpus response = await vertexRagDataServiceClient.GetRagCorpusAsync(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
GetRagFileRequest request = new GetRagFileRequest
{
    RagFileName = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]"),
};
// Make the request
RagFile response = vertexRagDataServiceClient.GetRagFile(request);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
RagFileName name = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]");
// Make the request
RagFile response = vertexRagDataServiceClient.GetRagFile(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]/ragFiles/[RAG_FILE]";
// Make the request
RagFile response = vertexRagDataServiceClient.GetRagFile(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
GetRagFileRequest request = new GetRagFileRequest
{
    RagFileName = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]"),
};
// Make the request
RagFile response = await vertexRagDataServiceClient.GetRagFileAsync(request);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
GetRagFileRequest request = new GetRagFileRequest
{
    RagFileName = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]"),
};
// Make the request
RagFile response = await vertexRagDataServiceClient.GetRagFileAsync(request);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagFileName name = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]");
// Make the request
RagFile response = await vertexRagDataServiceClient.GetRagFileAsync(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagFileName name = RagFileName.FromProjectLocationRagCorpusRagFile("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]", "[RAG_FILE]");
// Make the request
RagFile response = await vertexRagDataServiceClient.GetRagFileAsync(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]/ragFiles/[RAG_FILE]";
// Make the request
RagFile response = await vertexRagDataServiceClient.GetRagFileAsync(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]/ragFiles/[RAG_FILE]";
// Make the request
RagFile response = await vertexRagDataServiceClient.GetRagFileAsync(name);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
ImportRagFilesRequest request = new ImportRagFilesRequest
{
    ParentAsRagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
    ImportRagFilesConfig = new ImportRagFilesConfig(),
};
// Make the request
Operation<ImportRagFilesResponse, ImportRagFilesOperationMetadata> response = vertexRagDataServiceClient.ImportRagFiles(request);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
RagCorpusName parent = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
ImportRagFilesConfig importRagFilesConfig = new ImportRagFilesConfig();
// Make the request
Operation<ImportRagFilesResponse, ImportRagFilesOperationMetadata> response = vertexRagDataServiceClient.ImportRagFiles(parent, importRagFilesConfig);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
ImportRagFilesConfig importRagFilesConfig = new ImportRagFilesConfig();
// Make the request
Operation<ImportRagFilesResponse, ImportRagFilesOperationMetadata> response = vertexRagDataServiceClient.ImportRagFiles(parent, importRagFilesConfig);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
ImportRagFilesRequest request = new ImportRagFilesRequest
{
    ParentAsRagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
    ImportRagFilesConfig = new ImportRagFilesConfig(),
};
// Make the request
Operation<ImportRagFilesResponse, ImportRagFilesOperationMetadata> response = await vertexRagDataServiceClient.ImportRagFilesAsync(request);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
ImportRagFilesRequest request = new ImportRagFilesRequest
{
    ParentAsRagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
    ImportRagFilesConfig = new ImportRagFilesConfig(),
};
// Make the request
Operation<ImportRagFilesResponse, ImportRagFilesOperationMetadata> response = await vertexRagDataServiceClient.ImportRagFilesAsync(request);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagCorpusName parent = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
ImportRagFilesConfig importRagFilesConfig = new ImportRagFilesConfig();
// Make the request
Operation<ImportRagFilesResponse, ImportRagFilesOperationMetadata> response = await vertexRagDataServiceClient.ImportRagFilesAsync(parent, importRagFilesConfig);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagCorpusName parent = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
ImportRagFilesConfig importRagFilesConfig = new ImportRagFilesConfig();
// Make the request
Operation<ImportRagFilesResponse, ImportRagFilesOperationMetadata> response = await vertexRagDataServiceClient.ImportRagFilesAsync(parent, importRagFilesConfig);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
ImportRagFilesConfig importRagFilesConfig = new ImportRagFilesConfig();
// Make the request
Operation<ImportRagFilesResponse, ImportRagFilesOperationMetadata> response = await vertexRagDataServiceClient.ImportRagFilesAsync(parent, importRagFilesConfig);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
ImportRagFilesConfig importRagFilesConfig = new ImportRagFilesConfig();
// Make the request
Operation<ImportRagFilesResponse, ImportRagFilesOperationMetadata> response = await vertexRagDataServiceClient.ImportRagFilesAsync(parent, importRagFilesConfig);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListRagCorporaResponse, RagCorpus> response = vertexRagDataServiceClient.ListRagCorpora(parent);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
ListRagCorporaRequest request = new ListRagCorporaRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListRagCorporaResponse, RagCorpus> response = vertexRagDataServiceClient.ListRagCorpora(request);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListRagCorporaResponse, RagCorpus> response = vertexRagDataServiceClient.ListRagCorpora(parent);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListRagCorporaResponse, RagCorpus> response = vertexRagDataServiceClient.ListRagCorporaAsync(parent);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
ListRagCorporaRequest request = new ListRagCorporaRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListRagCorporaResponse, RagCorpus> response = vertexRagDataServiceClient.ListRagCorporaAsync(request);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListRagCorporaResponse, RagCorpus> response = vertexRagDataServiceClient.ListRagCorporaAsync(parent);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
ListRagFilesRequest request = new ListRagFilesRequest
{
    ParentAsRagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
};
// Make the request
PagedEnumerable<ListRagFilesResponse, RagFile> response = vertexRagDataServiceClient.ListRagFiles(request);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
RagCorpusName parent = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
// Make the request
PagedEnumerable<ListRagFilesResponse, RagFile> response = vertexRagDataServiceClient.ListRagFiles(parent);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
// Make the request
PagedEnumerable<ListRagFilesResponse, RagFile> response = vertexRagDataServiceClient.ListRagFiles(parent);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
ListRagFilesRequest request = new ListRagFilesRequest
{
    ParentAsRagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
};
// Make the request
PagedAsyncEnumerable<ListRagFilesResponse, RagFile> response = vertexRagDataServiceClient.ListRagFilesAsync(request);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagCorpusName parent = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
// Make the request
PagedAsyncEnumerable<ListRagFilesResponse, RagFile> response = vertexRagDataServiceClient.ListRagFilesAsync(parent);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
// Make the request
PagedAsyncEnumerable<ListRagFilesResponse, RagFile> response = vertexRagDataServiceClient.ListRagFilesAsync(parent);

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

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

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
RagCorpus ragCorpus = new RagCorpus();
// Make the request
Operation<RagCorpus, UpdateRagCorpusOperationMetadata> response = vertexRagDataServiceClient.UpdateRagCorpus(ragCorpus);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
UpdateRagCorpusRequest request = new UpdateRagCorpusRequest
{
    RagCorpus = new RagCorpus(),
};
// Make the request
Operation<RagCorpus, UpdateRagCorpusOperationMetadata> response = vertexRagDataServiceClient.UpdateRagCorpus(request);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagCorpus ragCorpus = new RagCorpus();
// Make the request
Operation<RagCorpus, UpdateRagCorpusOperationMetadata> response = await vertexRagDataServiceClient.UpdateRagCorpusAsync(ragCorpus);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagCorpus ragCorpus = new RagCorpus();
// Make the request
Operation<RagCorpus, UpdateRagCorpusOperationMetadata> response = await vertexRagDataServiceClient.UpdateRagCorpusAsync(ragCorpus);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateRagCorpusRequest request = new UpdateRagCorpusRequest
{
    RagCorpus = new RagCorpus(),
};
// Make the request
Operation<RagCorpus, UpdateRagCorpusOperationMetadata> response = await vertexRagDataServiceClient.UpdateRagCorpusAsync(request);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateRagCorpusRequest request = new UpdateRagCorpusRequest
{
    RagCorpus = new RagCorpus(),
};
// Make the request
Operation<RagCorpus, UpdateRagCorpusOperationMetadata> response = await vertexRagDataServiceClient.UpdateRagCorpusAsync(request);

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

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
RagCorpusName parent = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
RagFile ragFile = new RagFile();
UploadRagFileConfig uploadRagFileConfig = new UploadRagFileConfig();
// Make the request
UploadRagFileResponse response = vertexRagDataServiceClient.UploadRagFile(parent, ragFile, uploadRagFileConfig);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
UploadRagFileRequest request = new UploadRagFileRequest
{
    ParentAsRagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
    RagFile = new RagFile(),
    UploadRagFileConfig = new UploadRagFileConfig(),
};
// Make the request
UploadRagFileResponse response = vertexRagDataServiceClient.UploadRagFile(request);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = VertexRagDataServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
RagFile ragFile = new RagFile();
UploadRagFileConfig uploadRagFileConfig = new UploadRagFileConfig();
// Make the request
UploadRagFileResponse response = vertexRagDataServiceClient.UploadRagFile(parent, ragFile, uploadRagFileConfig);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagCorpusName parent = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
RagFile ragFile = new RagFile();
UploadRagFileConfig uploadRagFileConfig = new UploadRagFileConfig();
// Make the request
UploadRagFileResponse response = await vertexRagDataServiceClient.UploadRagFileAsync(parent, ragFile, uploadRagFileConfig);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
RagCorpusName parent = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]");
RagFile ragFile = new RagFile();
UploadRagFileConfig uploadRagFileConfig = new UploadRagFileConfig();
// Make the request
UploadRagFileResponse response = await vertexRagDataServiceClient.UploadRagFileAsync(parent, ragFile, uploadRagFileConfig);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
UploadRagFileRequest request = new UploadRagFileRequest
{
    ParentAsRagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
    RagFile = new RagFile(),
    UploadRagFileConfig = new UploadRagFileConfig(),
};
// Make the request
UploadRagFileResponse response = await vertexRagDataServiceClient.UploadRagFileAsync(request);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
UploadRagFileRequest request = new UploadRagFileRequest
{
    ParentAsRagCorpusName = RagCorpusName.FromProjectLocationRagCorpus("[PROJECT]", "[LOCATION]", "[RAG_CORPUS]"),
    RagFile = new RagFile(),
    UploadRagFileConfig = new UploadRagFileConfig(),
};
// Make the request
UploadRagFileResponse response = await vertexRagDataServiceClient.UploadRagFileAsync(request);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
RagFile ragFile = new RagFile();
UploadRagFileConfig uploadRagFileConfig = new UploadRagFileConfig();
// Make the request
UploadRagFileResponse response = await vertexRagDataServiceClient.UploadRagFileAsync(parent, ragFile, uploadRagFileConfig);

// Create client
VertexRagDataServiceClient vertexRagDataServiceClient = await VertexRagDataServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/ragCorpora/[RAG_CORPUS]";
RagFile ragFile = new RagFile();
UploadRagFileConfig uploadRagFileConfig = new UploadRagFileConfig();
// Make the request
UploadRagFileResponse response = await vertexRagDataServiceClient.UploadRagFileAsync(parent, ragFile, uploadRagFileConfig);