Cloud FTP v1 API - Class CloudFtpClient (1.0.0-beta01)

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Server server = new Server();
string serverId = "";
// Make the request
Operation<Server, OperationMetadata> response = cloudFtpClient.CreateServer(parent, server, serverId);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
CreateServerRequest request = new CreateServerRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServerId = "",
    Server = new Server(),
    RequestId = "",
};
// Make the request
Operation<Server, OperationMetadata> response = cloudFtpClient.CreateServer(request);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Server server = new Server();
string serverId = "";
// Make the request
Operation<Server, OperationMetadata> response = cloudFtpClient.CreateServer(parent, server, serverId);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Server server = new Server();
string serverId = "";
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.CreateServerAsync(parent, server, serverId);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Server server = new Server();
string serverId = "";
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.CreateServerAsync(parent, server, serverId);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
CreateServerRequest request = new CreateServerRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServerId = "",
    Server = new Server(),
    RequestId = "",
};
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.CreateServerAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
CreateServerRequest request = new CreateServerRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServerId = "",
    Server = new Server(),
    RequestId = "",
};
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.CreateServerAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Server server = new Server();
string serverId = "";
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.CreateServerAsync(parent, server, serverId);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Server server = new Server();
string serverId = "";
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.CreateServerAsync(parent, server, serverId);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
CreateUserRequest request = new CreateUserRequest
{
    ParentAsServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
    UserId = "",
    User = new User(),
    RequestId = "",
};
// Make the request
Operation<User, OperationMetadata> response = cloudFtpClient.CreateUser(request);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
ServerName parent = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
User user = new User();
string userId = "";
// Make the request
Operation<User, OperationMetadata> response = cloudFtpClient.CreateUser(parent, user, userId);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
User user = new User();
string userId = "";
// Make the request
Operation<User, OperationMetadata> response = cloudFtpClient.CreateUser(parent, user, userId);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
CreateUserRequest request = new CreateUserRequest
{
    ParentAsServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
    UserId = "",
    User = new User(),
    RequestId = "",
};
// Make the request
Operation<User, OperationMetadata> response = await cloudFtpClient.CreateUserAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
CreateUserRequest request = new CreateUserRequest
{
    ParentAsServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
    UserId = "",
    User = new User(),
    RequestId = "",
};
// Make the request
Operation<User, OperationMetadata> response = await cloudFtpClient.CreateUserAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ServerName parent = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
User user = new User();
string userId = "";
// Make the request
Operation<User, OperationMetadata> response = await cloudFtpClient.CreateUserAsync(parent, user, userId);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ServerName parent = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
User user = new User();
string userId = "";
// Make the request
Operation<User, OperationMetadata> response = await cloudFtpClient.CreateUserAsync(parent, user, userId);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
User user = new User();
string userId = "";
// Make the request
Operation<User, OperationMetadata> response = await cloudFtpClient.CreateUserAsync(parent, user, userId);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
User user = new User();
string userId = "";
// Make the request
Operation<User, OperationMetadata> response = await cloudFtpClient.CreateUserAsync(parent, user, userId);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
DeleteServerRequest request = new DeleteServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = cloudFtpClient.DeleteServer(request);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = cloudFtpClient.PollOnceDeleteServer(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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Operation<Empty, OperationMetadata> response = cloudFtpClient.DeleteServer(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = cloudFtpClient.PollOnceDeleteServer(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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Operation<Empty, OperationMetadata> response = cloudFtpClient.DeleteServer(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = cloudFtpClient.PollOnceDeleteServer(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
DeleteServerRequest request = new DeleteServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteServerAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteServerAsync(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
DeleteServerRequest request = new DeleteServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteServerAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteServerAsync(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteServerAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteServerAsync(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteServerAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteServerAsync(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteServerAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteServerAsync(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteServerAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteServerAsync(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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
DeleteUserRequest request = new DeleteUserRequest
{
    UserName = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]"),
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = cloudFtpClient.DeleteUser(request);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = cloudFtpClient.PollOnceDeleteUser(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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
UserName name = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]");
// Make the request
Operation<Empty, OperationMetadata> response = cloudFtpClient.DeleteUser(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = cloudFtpClient.PollOnceDeleteUser(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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]/users/[USER]";
// Make the request
Operation<Empty, OperationMetadata> response = cloudFtpClient.DeleteUser(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = cloudFtpClient.PollOnceDeleteUser(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
DeleteUserRequest request = new DeleteUserRequest
{
    UserName = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]"),
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteUserAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteUserAsync(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
DeleteUserRequest request = new DeleteUserRequest
{
    UserName = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]"),
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteUserAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteUserAsync(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
UserName name = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteUserAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteUserAsync(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
UserName name = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteUserAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteUserAsync(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]/users/[USER]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteUserAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteUserAsync(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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]/users/[USER]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudFtpClient.DeleteUserAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, OperationMetadata> retrievedResponse = await cloudFtpClient.PollOnceDeleteUserAsync(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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
GetServerRequest request = new GetServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
    View = ServerView.Unspecified,
};
// Make the request
Server response = cloudFtpClient.GetServer(request);

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Server response = cloudFtpClient.GetServer(name);

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Server response = cloudFtpClient.GetServer(name);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
GetServerRequest request = new GetServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
    View = ServerView.Unspecified,
};
// Make the request
Server response = await cloudFtpClient.GetServerAsync(request);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
GetServerRequest request = new GetServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
    View = ServerView.Unspecified,
};
// Make the request
Server response = await cloudFtpClient.GetServerAsync(request);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Server response = await cloudFtpClient.GetServerAsync(name);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Server response = await cloudFtpClient.GetServerAsync(name);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Server response = await cloudFtpClient.GetServerAsync(name);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Server response = await cloudFtpClient.GetServerAsync(name);

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
GetUserRequest request = new GetUserRequest
{
    UserName = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]"),
    View = UserView.Unspecified,
};
// Make the request
User response = cloudFtpClient.GetUser(request);

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
UserName name = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]");
// Make the request
User response = cloudFtpClient.GetUser(name);

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]/users/[USER]";
// Make the request
User response = cloudFtpClient.GetUser(name);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
GetUserRequest request = new GetUserRequest
{
    UserName = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]"),
    View = UserView.Unspecified,
};
// Make the request
User response = await cloudFtpClient.GetUserAsync(request);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
GetUserRequest request = new GetUserRequest
{
    UserName = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]"),
    View = UserView.Unspecified,
};
// Make the request
User response = await cloudFtpClient.GetUserAsync(request);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
UserName name = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]");
// Make the request
User response = await cloudFtpClient.GetUserAsync(name);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
UserName name = UserName.FromProjectLocationServerUser("[PROJECT]", "[LOCATION]", "[SERVER]", "[USER]");
// Make the request
User response = await cloudFtpClient.GetUserAsync(name);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]/users/[USER]";
// Make the request
User response = await cloudFtpClient.GetUserAsync(name);

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]/users/[USER]";
// Make the request
User response = await cloudFtpClient.GetUserAsync(name);

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListServersResponse, Server> response = cloudFtpClient.ListServers(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Server 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 (ListServersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Server 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<Server> 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 (Server 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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
ListServersRequest request = new ListServersRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
    View = ServerView.Unspecified,
};
// Make the request
PagedEnumerable<ListServersResponse, Server> response = cloudFtpClient.ListServers(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Server 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 (ListServersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Server 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<Server> 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 (Server 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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListServersResponse, Server> response = cloudFtpClient.ListServers(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Server 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 (ListServersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Server 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<Server> 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 (Server 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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListServersResponse, Server> response = cloudFtpClient.ListServersAsync(parent);

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

// Or iterate over pages (of server-defined size), performing one RPC per page
await foreach (ListServersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Server 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<Server> 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 (Server 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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ListServersRequest request = new ListServersRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
    View = ServerView.Unspecified,
};
// Make the request
PagedAsyncEnumerable<ListServersResponse, Server> response = cloudFtpClient.ListServersAsync(request);

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

// Or iterate over pages (of server-defined size), performing one RPC per page
await foreach (ListServersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Server 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<Server> 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 (Server 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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListServersResponse, Server> response = cloudFtpClient.ListServersAsync(parent);

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

// Or iterate over pages (of server-defined size), performing one RPC per page
await foreach (ListServersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Server 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<Server> 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 (Server 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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
ListUsersRequest request = new ListUsersRequest
{
    ParentAsServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
    Filter = "",
    OrderBy = "",
    View = UserView.Unspecified,
};
// Make the request
PagedEnumerable<ListUsersResponse, User> response = cloudFtpClient.ListUsers(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (User 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 (ListUsersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (User 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<User> 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 (User 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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
ServerName parent = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
PagedEnumerable<ListUsersResponse, User> response = cloudFtpClient.ListUsers(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (User 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 (ListUsersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (User 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<User> 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 (User 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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
PagedEnumerable<ListUsersResponse, User> response = cloudFtpClient.ListUsers(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (User 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 (ListUsersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (User 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<User> 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 (User 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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ListUsersRequest request = new ListUsersRequest
{
    ParentAsServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
    Filter = "",
    OrderBy = "",
    View = UserView.Unspecified,
};
// Make the request
PagedAsyncEnumerable<ListUsersResponse, User> response = cloudFtpClient.ListUsersAsync(request);

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

// Or iterate over pages (of server-defined size), performing one RPC per page
await foreach (ListUsersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (User 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<User> 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 (User 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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ServerName parent = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
PagedAsyncEnumerable<ListUsersResponse, User> response = cloudFtpClient.ListUsersAsync(parent);

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

// Or iterate over pages (of server-defined size), performing one RPC per page
await foreach (ListUsersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (User 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<User> 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 (User 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
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
PagedAsyncEnumerable<ListUsersResponse, User> response = cloudFtpClient.ListUsersAsync(parent);

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

// Or iterate over pages (of server-defined size), performing one RPC per page
await foreach (ListUsersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (User 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<User> 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 (User 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
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Operation<Server, OperationMetadata> response = cloudFtpClient.StartServer(name);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
StartServerRequest request = new StartServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
};
// Make the request
Operation<Server, OperationMetadata> response = cloudFtpClient.StartServer(request);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Operation<Server, OperationMetadata> response = cloudFtpClient.StartServer(name);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StartServerAsync(name);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StartServerAsync(name);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
StartServerRequest request = new StartServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
};
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StartServerAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
StartServerRequest request = new StartServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
};
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StartServerAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StartServerAsync(name);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StartServerAsync(name);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Operation<Server, OperationMetadata> response = cloudFtpClient.StopServer(name);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
StopServerRequest request = new StopServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
};
// Make the request
Operation<Server, OperationMetadata> response = cloudFtpClient.StopServer(request);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Operation<Server, OperationMetadata> response = cloudFtpClient.StopServer(name);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StopServerAsync(name);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
ServerName name = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]");
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StopServerAsync(name);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
StopServerRequest request = new StopServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
};
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StopServerAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
StopServerRequest request = new StopServerRequest
{
    ServerName = ServerName.FromProjectLocationServer("[PROJECT]", "[LOCATION]", "[SERVER]"),
};
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StopServerAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StopServerAsync(name);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/servers/[SERVER]";
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.StopServerAsync(name);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
Server server = new Server();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Server, OperationMetadata> response = cloudFtpClient.UpdateServer(server, updateMask);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
UpdateServerRequest request = new UpdateServerRequest
{
    UpdateMask = new FieldMask(),
    Server = new Server(),
    RequestId = "",
};
// Make the request
Operation<Server, OperationMetadata> response = cloudFtpClient.UpdateServer(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
Server server = new Server();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.UpdateServerAsync(server, updateMask);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
Server server = new Server();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.UpdateServerAsync(server, updateMask);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
UpdateServerRequest request = new UpdateServerRequest
{
    UpdateMask = new FieldMask(),
    Server = new Server(),
    RequestId = "",
};
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.UpdateServerAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
UpdateServerRequest request = new UpdateServerRequest
{
    UpdateMask = new FieldMask(),
    Server = new Server(),
    RequestId = "",
};
// Make the request
Operation<Server, OperationMetadata> response = await cloudFtpClient.UpdateServerAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
UpdateUserRequest request = new UpdateUserRequest
{
    UpdateMask = new FieldMask(),
    User = new User(),
};
// Make the request
Operation<User, OperationMetadata> response = cloudFtpClient.UpdateUser(request);

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

// Create client
CloudFtpClient cloudFtpClient = CloudFtpClient.Create();
// Initialize request argument(s)
User user = new User();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<User, OperationMetadata> response = cloudFtpClient.UpdateUser(user, updateMask);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
UpdateUserRequest request = new UpdateUserRequest
{
    UpdateMask = new FieldMask(),
    User = new User(),
};
// Make the request
Operation<User, OperationMetadata> response = await cloudFtpClient.UpdateUserAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
UpdateUserRequest request = new UpdateUserRequest
{
    UpdateMask = new FieldMask(),
    User = new User(),
};
// Make the request
Operation<User, OperationMetadata> response = await cloudFtpClient.UpdateUserAsync(request);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
User user = new User();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<User, OperationMetadata> response = await cloudFtpClient.UpdateUserAsync(user, updateMask);

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

// Create client
CloudFtpClient cloudFtpClient = await CloudFtpClient.CreateAsync();
// Initialize request argument(s)
User user = new User();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<User, OperationMetadata> response = await cloudFtpClient.UpdateUserAsync(user, updateMask);

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