Compute Engine v1 API - Class OrganizationSecurityPoliciesClient (3.18.0)

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
AddAssociationOrganizationSecurityPolicyRequest request = new AddAssociationOrganizationSecurityPolicyRequest
{
    SecurityPolicyAssociationResource = new SecurityPolicyAssociation(),
    RequestId = "",
    SecurityPolicy = "",
    ReplaceExistingAssociation = false,
};
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.AddAssociation(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicyAssociation securityPolicyAssociationResource = new SecurityPolicyAssociation();
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.AddAssociation(securityPolicy, securityPolicyAssociationResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
AddAssociationOrganizationSecurityPolicyRequest request = new AddAssociationOrganizationSecurityPolicyRequest
{
    SecurityPolicyAssociationResource = new SecurityPolicyAssociation(),
    RequestId = "",
    SecurityPolicy = "",
    ReplaceExistingAssociation = false,
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.AddAssociationAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
AddAssociationOrganizationSecurityPolicyRequest request = new AddAssociationOrganizationSecurityPolicyRequest
{
    SecurityPolicyAssociationResource = new SecurityPolicyAssociation(),
    RequestId = "",
    SecurityPolicy = "",
    ReplaceExistingAssociation = false,
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.AddAssociationAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicyAssociation securityPolicyAssociationResource = new SecurityPolicyAssociation();
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.AddAssociationAsync(securityPolicy, securityPolicyAssociationResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicyAssociation securityPolicyAssociationResource = new SecurityPolicyAssociation();
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.AddAssociationAsync(securityPolicy, securityPolicyAssociationResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
AddRuleOrganizationSecurityPolicyRequest request = new AddRuleOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SecurityPolicyRuleResource = new SecurityPolicyRule(),
};
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.AddRule(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicyRule securityPolicyRuleResource = new SecurityPolicyRule();
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.AddRule(securityPolicy, securityPolicyRuleResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
AddRuleOrganizationSecurityPolicyRequest request = new AddRuleOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SecurityPolicyRuleResource = new SecurityPolicyRule(),
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.AddRuleAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
AddRuleOrganizationSecurityPolicyRequest request = new AddRuleOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SecurityPolicyRuleResource = new SecurityPolicyRule(),
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.AddRuleAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicyRule securityPolicyRuleResource = new SecurityPolicyRule();
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.AddRuleAsync(securityPolicy, securityPolicyRuleResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicyRule securityPolicyRuleResource = new SecurityPolicyRule();
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.AddRuleAsync(securityPolicy, securityPolicyRuleResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
CopyRulesOrganizationSecurityPolicyRequest request = new CopyRulesOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SourceSecurityPolicy = "",
};
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.CopyRules(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.CopyRules(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
CopyRulesOrganizationSecurityPolicyRequest request = new CopyRulesOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SourceSecurityPolicy = "",
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.CopyRulesAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
CopyRulesOrganizationSecurityPolicyRequest request = new CopyRulesOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SourceSecurityPolicy = "",
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.CopyRulesAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.CopyRulesAsync(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.CopyRulesAsync(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
DeleteOrganizationSecurityPolicyRequest request = new DeleteOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
};
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.Delete(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.Delete(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
DeleteOrganizationSecurityPolicyRequest request = new DeleteOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.DeleteAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
DeleteOrganizationSecurityPolicyRequest request = new DeleteOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.DeleteAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.DeleteAsync(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.DeleteAsync(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
GetOrganizationSecurityPolicyRequest request = new GetOrganizationSecurityPolicyRequest { SecurityPolicy = "", };
// Make the request
SecurityPolicy response = organizationSecurityPoliciesClient.Get(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
SecurityPolicy response = organizationSecurityPoliciesClient.Get(securityPolicy);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
GetAssociationOrganizationSecurityPolicyRequest request = new GetAssociationOrganizationSecurityPolicyRequest
{
    Name = "",
    SecurityPolicy = "",
};
// Make the request
SecurityPolicyAssociation response = organizationSecurityPoliciesClient.GetAssociation(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
SecurityPolicyAssociation response = organizationSecurityPoliciesClient.GetAssociation(securityPolicy);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
GetAssociationOrganizationSecurityPolicyRequest request = new GetAssociationOrganizationSecurityPolicyRequest
{
    Name = "",
    SecurityPolicy = "",
};
// Make the request
SecurityPolicyAssociation response = await organizationSecurityPoliciesClient.GetAssociationAsync(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
GetAssociationOrganizationSecurityPolicyRequest request = new GetAssociationOrganizationSecurityPolicyRequest
{
    Name = "",
    SecurityPolicy = "",
};
// Make the request
SecurityPolicyAssociation response = await organizationSecurityPoliciesClient.GetAssociationAsync(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
SecurityPolicyAssociation response = await organizationSecurityPoliciesClient.GetAssociationAsync(securityPolicy);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
SecurityPolicyAssociation response = await organizationSecurityPoliciesClient.GetAssociationAsync(securityPolicy);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
GetOrganizationSecurityPolicyRequest request = new GetOrganizationSecurityPolicyRequest { SecurityPolicy = "", };
// Make the request
SecurityPolicy response = await organizationSecurityPoliciesClient.GetAsync(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
GetOrganizationSecurityPolicyRequest request = new GetOrganizationSecurityPolicyRequest { SecurityPolicy = "", };
// Make the request
SecurityPolicy response = await organizationSecurityPoliciesClient.GetAsync(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
SecurityPolicy response = await organizationSecurityPoliciesClient.GetAsync(securityPolicy);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
SecurityPolicy response = await organizationSecurityPoliciesClient.GetAsync(securityPolicy);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
GetRuleOrganizationSecurityPolicyRequest request = new GetRuleOrganizationSecurityPolicyRequest
{
    SecurityPolicy = "",
    Priority = 0,
};
// Make the request
SecurityPolicyRule response = organizationSecurityPoliciesClient.GetRule(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
SecurityPolicyRule response = organizationSecurityPoliciesClient.GetRule(securityPolicy);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
GetRuleOrganizationSecurityPolicyRequest request = new GetRuleOrganizationSecurityPolicyRequest
{
    SecurityPolicy = "",
    Priority = 0,
};
// Make the request
SecurityPolicyRule response = await organizationSecurityPoliciesClient.GetRuleAsync(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
GetRuleOrganizationSecurityPolicyRequest request = new GetRuleOrganizationSecurityPolicyRequest
{
    SecurityPolicy = "",
    Priority = 0,
};
// Make the request
SecurityPolicyRule response = await organizationSecurityPoliciesClient.GetRuleAsync(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
SecurityPolicyRule response = await organizationSecurityPoliciesClient.GetRuleAsync(securityPolicy);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
SecurityPolicyRule response = await organizationSecurityPoliciesClient.GetRuleAsync(securityPolicy);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
InsertOrganizationSecurityPolicyRequest request = new InsertOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicyResource = new SecurityPolicy(),
    ParentId = "",
};
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.Insert(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
SecurityPolicy securityPolicyResource = new SecurityPolicy();
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.Insert(securityPolicyResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
InsertOrganizationSecurityPolicyRequest request = new InsertOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicyResource = new SecurityPolicy(),
    ParentId = "",
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.InsertAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
InsertOrganizationSecurityPolicyRequest request = new InsertOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicyResource = new SecurityPolicy(),
    ParentId = "",
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.InsertAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
SecurityPolicy securityPolicyResource = new SecurityPolicy();
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.InsertAsync(securityPolicyResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
SecurityPolicy securityPolicyResource = new SecurityPolicy();
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.InsertAsync(securityPolicyResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
ListOrganizationSecurityPoliciesRequest request = new ListOrganizationSecurityPoliciesRequest
{
    OrderBy = "",
    Filter = "",
    ParentId = "",
    ReturnPartialSuccess = false,
};
// Make the request
PagedEnumerable<SecurityPolicyList, SecurityPolicy> response = organizationSecurityPoliciesClient.List(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (SecurityPolicy 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 (SecurityPolicyList page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (SecurityPolicy 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<SecurityPolicy> 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 (SecurityPolicy 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
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Make the request
PagedEnumerable<SecurityPolicyList, SecurityPolicy> response = organizationSecurityPoliciesClient.List();

// Iterate over all response items, lazily performing RPCs as required
foreach (SecurityPolicy 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 (SecurityPolicyList page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (SecurityPolicy 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<SecurityPolicy> 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 (SecurityPolicy 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
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Make the request
OrganizationSecurityPoliciesListAssociationsResponse response = organizationSecurityPoliciesClient.ListAssociations();

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
ListAssociationsOrganizationSecurityPolicyRequest request = new ListAssociationsOrganizationSecurityPolicyRequest { TargetResource = "", };
// Make the request
OrganizationSecurityPoliciesListAssociationsResponse response = organizationSecurityPoliciesClient.ListAssociations(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Make the request
OrganizationSecurityPoliciesListAssociationsResponse response = await organizationSecurityPoliciesClient.ListAssociationsAsync();

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
ListAssociationsOrganizationSecurityPolicyRequest request = new ListAssociationsOrganizationSecurityPolicyRequest { TargetResource = "", };
// Make the request
OrganizationSecurityPoliciesListAssociationsResponse response = await organizationSecurityPoliciesClient.ListAssociationsAsync(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
ListAssociationsOrganizationSecurityPolicyRequest request = new ListAssociationsOrganizationSecurityPolicyRequest { TargetResource = "", };
// Make the request
OrganizationSecurityPoliciesListAssociationsResponse response = await organizationSecurityPoliciesClient.ListAssociationsAsync(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Make the request
OrganizationSecurityPoliciesListAssociationsResponse response = await organizationSecurityPoliciesClient.ListAssociationsAsync();

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
ListOrganizationSecurityPoliciesRequest request = new ListOrganizationSecurityPoliciesRequest
{
    OrderBy = "",
    Filter = "",
    ParentId = "",
    ReturnPartialSuccess = false,
};
// Make the request
PagedAsyncEnumerable<SecurityPolicyList, SecurityPolicy> response = organizationSecurityPoliciesClient.ListAsync(request);

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

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((SecurityPolicyList page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (SecurityPolicy 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<SecurityPolicy> 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 (SecurityPolicy 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
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Make the request
PagedAsyncEnumerable<SecurityPolicyList, SecurityPolicy> response = organizationSecurityPoliciesClient.ListAsync();

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

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((SecurityPolicyList page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (SecurityPolicy 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<SecurityPolicy> 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 (SecurityPolicy 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
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Make the request
SecurityPoliciesListPreconfiguredExpressionSetsResponse response = organizationSecurityPoliciesClient.ListPreconfiguredExpressionSets();

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest request = new ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest
{
    PageToken = "",
    MaxResults = 0U,
    OrderBy = "",
    Filter = "",
    ParentId = "",
    ReturnPartialSuccess = false,
};
// Make the request
SecurityPoliciesListPreconfiguredExpressionSetsResponse response = organizationSecurityPoliciesClient.ListPreconfiguredExpressionSets(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Make the request
SecurityPoliciesListPreconfiguredExpressionSetsResponse response = await organizationSecurityPoliciesClient.ListPreconfiguredExpressionSetsAsync();

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest request = new ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest
{
    PageToken = "",
    MaxResults = 0U,
    OrderBy = "",
    Filter = "",
    ParentId = "",
    ReturnPartialSuccess = false,
};
// Make the request
SecurityPoliciesListPreconfiguredExpressionSetsResponse response = await organizationSecurityPoliciesClient.ListPreconfiguredExpressionSetsAsync(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest request = new ListPreconfiguredExpressionSetsOrganizationSecurityPoliciesRequest
{
    PageToken = "",
    MaxResults = 0U,
    OrderBy = "",
    Filter = "",
    ParentId = "",
    ReturnPartialSuccess = false,
};
// Make the request
SecurityPoliciesListPreconfiguredExpressionSetsResponse response = await organizationSecurityPoliciesClient.ListPreconfiguredExpressionSetsAsync(request);

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Make the request
SecurityPoliciesListPreconfiguredExpressionSetsResponse response = await organizationSecurityPoliciesClient.ListPreconfiguredExpressionSetsAsync();

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
MoveOrganizationSecurityPolicyRequest request = new MoveOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    ParentId = "",
};
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.Move(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.Move(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
MoveOrganizationSecurityPolicyRequest request = new MoveOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    ParentId = "",
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.MoveAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
MoveOrganizationSecurityPolicyRequest request = new MoveOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    ParentId = "",
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.MoveAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.MoveAsync(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.MoveAsync(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
PatchOrganizationSecurityPolicyRequest request = new PatchOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SecurityPolicyResource = new SecurityPolicy(),
};
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.Patch(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicy securityPolicyResource = new SecurityPolicy();
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.Patch(securityPolicy, securityPolicyResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
PatchOrganizationSecurityPolicyRequest request = new PatchOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SecurityPolicyResource = new SecurityPolicy(),
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.PatchAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
PatchOrganizationSecurityPolicyRequest request = new PatchOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SecurityPolicyResource = new SecurityPolicy(),
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.PatchAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicy securityPolicyResource = new SecurityPolicy();
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.PatchAsync(securityPolicy, securityPolicyResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicy securityPolicyResource = new SecurityPolicy();
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.PatchAsync(securityPolicy, securityPolicyResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
PatchRuleOrganizationSecurityPolicyRequest request = new PatchRuleOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SecurityPolicyRuleResource = new SecurityPolicyRule(),
    Priority = 0,
};
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.PatchRule(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicyRule securityPolicyRuleResource = new SecurityPolicyRule();
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.PatchRule(securityPolicy, securityPolicyRuleResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
PatchRuleOrganizationSecurityPolicyRequest request = new PatchRuleOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SecurityPolicyRuleResource = new SecurityPolicyRule(),
    Priority = 0,
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.PatchRuleAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
PatchRuleOrganizationSecurityPolicyRequest request = new PatchRuleOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    SecurityPolicyRuleResource = new SecurityPolicyRule(),
    Priority = 0,
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.PatchRuleAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicyRule securityPolicyRuleResource = new SecurityPolicyRule();
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.PatchRuleAsync(securityPolicy, securityPolicyRuleResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
SecurityPolicyRule securityPolicyRuleResource = new SecurityPolicyRule();
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.PatchRuleAsync(securityPolicy, securityPolicyRuleResource);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
RemoveAssociationOrganizationSecurityPolicyRequest request = new RemoveAssociationOrganizationSecurityPolicyRequest
{
    Name = "",
    RequestId = "",
    SecurityPolicy = "",
};
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.RemoveAssociation(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.RemoveAssociation(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
RemoveAssociationOrganizationSecurityPolicyRequest request = new RemoveAssociationOrganizationSecurityPolicyRequest
{
    Name = "",
    RequestId = "",
    SecurityPolicy = "",
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.RemoveAssociationAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
RemoveAssociationOrganizationSecurityPolicyRequest request = new RemoveAssociationOrganizationSecurityPolicyRequest
{
    Name = "",
    RequestId = "",
    SecurityPolicy = "",
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.RemoveAssociationAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.RemoveAssociationAsync(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.RemoveAssociationAsync(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
RemoveRuleOrganizationSecurityPolicyRequest request = new RemoveRuleOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    Priority = 0,
};
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.RemoveRule(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = OrganizationSecurityPoliciesClient.Create();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = organizationSecurityPoliciesClient.RemoveRule(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
RemoveRuleOrganizationSecurityPolicyRequest request = new RemoveRuleOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    Priority = 0,
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.RemoveRuleAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
RemoveRuleOrganizationSecurityPolicyRequest request = new RemoveRuleOrganizationSecurityPolicyRequest
{
    RequestId = "",
    SecurityPolicy = "",
    Priority = 0,
};
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.RemoveRuleAsync(request);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.RemoveRuleAsync(securityPolicy);

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

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

// Create client
OrganizationSecurityPoliciesClient organizationSecurityPoliciesClient = await OrganizationSecurityPoliciesClient.CreateAsync();
// Initialize request argument(s)
string securityPolicy = "";
// Make the request
lro::Operation<Operation, Operation> response = await organizationSecurityPoliciesClient.RemoveRuleAsync(securityPolicy);

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

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