Audit Manager v1 API - Class AuditManagerClient (1.2.0)

// Create client
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
EnrollResourceRequest request = new EnrollResourceRequest
{
    Scope = "",
    Destinations =
    {
        new EnrollResourceRequest.Types.EligibleDestination(),
    },
};
// Make the request
Enrollment response = auditManagerClient.EnrollResource(request);

// Create client
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
string scope = "";
IEnumerable<EnrollResourceRequest.Types.EligibleDestination> destinations = new EnrollResourceRequest.Types.EligibleDestination[]
{
    new EnrollResourceRequest.Types.EligibleDestination(),
};
// Make the request
Enrollment response = auditManagerClient.EnrollResource(scope, destinations);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
EnrollResourceRequest request = new EnrollResourceRequest
{
    Scope = "",
    Destinations =
    {
        new EnrollResourceRequest.Types.EligibleDestination(),
    },
};
// Make the request
Enrollment response = await auditManagerClient.EnrollResourceAsync(request);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
EnrollResourceRequest request = new EnrollResourceRequest
{
    Scope = "",
    Destinations =
    {
        new EnrollResourceRequest.Types.EligibleDestination(),
    },
};
// Make the request
Enrollment response = await auditManagerClient.EnrollResourceAsync(request);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
string scope = "";
IEnumerable<EnrollResourceRequest.Types.EligibleDestination> destinations = new EnrollResourceRequest.Types.EligibleDestination[]
{
    new EnrollResourceRequest.Types.EligibleDestination(),
};
// Make the request
Enrollment response = await auditManagerClient.EnrollResourceAsync(scope, destinations);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
string scope = "";
IEnumerable<EnrollResourceRequest.Types.EligibleDestination> destinations = new EnrollResourceRequest.Types.EligibleDestination[]
{
    new EnrollResourceRequest.Types.EligibleDestination(),
};
// Make the request
Enrollment response = await auditManagerClient.EnrollResourceAsync(scope, destinations);

// Create client
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
GenerateAuditReportRequest request = new GenerateAuditReportRequest
{
    Scope = "",
    GcsUri = "",
    ReportFormat = GenerateAuditReportRequest.Types.AuditReportFormat.Unspecified,
    ComplianceFramework = "",
    ValidateOnly = false,
};
// Make the request
Operation<AuditReport, OperationMetadata> response = auditManagerClient.GenerateAuditReport(request);

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

// Or 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<AuditReport, OperationMetadata> retrievedResponse = auditManagerClient.PollOnceGenerateAuditReport(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AuditReport retrievedResult = retrievedResponse.Result;
}

            // Create client
            AuditManagerClient auditManagerClient = AuditManagerClient.Create();
            // Initialize request argument(s)
            string scope = "";
            string gcsUri = "";
            string complianceStandard = "";
            GenerateAuditReportRequest.Types.AuditReportFormat reportFormat = GenerateAuditReportRequest.Types.AuditReportFormat.Unspecified;
            // Make the request
#pragma warning disable CS0612
            Operation<AuditReport, OperationMetadata> response = auditManagerClient.GenerateAuditReport(scope, gcsUri, complianceStandard, reportFormat);
#pragma warning restore CS0612

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

            // Or 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<AuditReport, OperationMetadata> retrievedResponse = auditManagerClient.PollOnceGenerateAuditReport(operationName);
            // Check if the retrieved long-running operation has completed
            if (retrievedResponse.IsCompleted)
            {
                // If it has completed, then access the result
                AuditReport retrievedResult = retrievedResponse.Result;
            }

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
GenerateAuditReportRequest request = new GenerateAuditReportRequest
{
    Scope = "",
    GcsUri = "",
    ReportFormat = GenerateAuditReportRequest.Types.AuditReportFormat.Unspecified,
    ComplianceFramework = "",
    ValidateOnly = false,
};
// Make the request
Operation<AuditReport, OperationMetadata> response = await auditManagerClient.GenerateAuditReportAsync(request);

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

// Or 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<AuditReport, OperationMetadata> retrievedResponse = await auditManagerClient.PollOnceGenerateAuditReportAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AuditReport retrievedResult = retrievedResponse.Result;
}

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
GenerateAuditReportRequest request = new GenerateAuditReportRequest
{
    Scope = "",
    GcsUri = "",
    ReportFormat = GenerateAuditReportRequest.Types.AuditReportFormat.Unspecified,
    ComplianceFramework = "",
    ValidateOnly = false,
};
// Make the request
Operation<AuditReport, OperationMetadata> response = await auditManagerClient.GenerateAuditReportAsync(request);

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

// Or 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<AuditReport, OperationMetadata> retrievedResponse = await auditManagerClient.PollOnceGenerateAuditReportAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AuditReport retrievedResult = retrievedResponse.Result;
}

            // Create client
            AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
            // Initialize request argument(s)
            string scope = "";
            string gcsUri = "";
            string complianceStandard = "";
            GenerateAuditReportRequest.Types.AuditReportFormat reportFormat = GenerateAuditReportRequest.Types.AuditReportFormat.Unspecified;
            // Make the request
#pragma warning disable CS0612
            Operation<AuditReport, OperationMetadata> response = await auditManagerClient.GenerateAuditReportAsync(scope, gcsUri, complianceStandard, reportFormat);
#pragma warning restore CS0612

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

            // Or 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<AuditReport, OperationMetadata> retrievedResponse = await auditManagerClient.PollOnceGenerateAuditReportAsync(operationName);
            // Check if the retrieved long-running operation has completed
            if (retrievedResponse.IsCompleted)
            {
                // If it has completed, then access the result
                AuditReport retrievedResult = retrievedResponse.Result;
            }

            // Create client
            AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
            // Initialize request argument(s)
            string scope = "";
            string gcsUri = "";
            string complianceStandard = "";
            GenerateAuditReportRequest.Types.AuditReportFormat reportFormat = GenerateAuditReportRequest.Types.AuditReportFormat.Unspecified;
            // Make the request
#pragma warning disable CS0612
            Operation<AuditReport, OperationMetadata> response = await auditManagerClient.GenerateAuditReportAsync(scope, gcsUri, complianceStandard, reportFormat);
#pragma warning restore CS0612

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

            // Or 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<AuditReport, OperationMetadata> retrievedResponse = await auditManagerClient.PollOnceGenerateAuditReportAsync(operationName);
            // Check if the retrieved long-running operation has completed
            if (retrievedResponse.IsCompleted)
            {
                // If it has completed, then access the result
                AuditReport retrievedResult = retrievedResponse.Result;
            }

// Create client
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
GenerateAuditScopeReportRequest request = new GenerateAuditScopeReportRequest
{
    Scope = "",
    ReportFormat = GenerateAuditScopeReportRequest.Types.AuditScopeReportFormat.Unspecified,
    ComplianceFramework = "",
};
// Make the request
AuditScopeReport response = auditManagerClient.GenerateAuditScopeReport(request);

            // Create client
            AuditManagerClient auditManagerClient = AuditManagerClient.Create();
            // Initialize request argument(s)
            string scope = "";
            string complianceStandard = "";
            GenerateAuditScopeReportRequest.Types.AuditScopeReportFormat reportFormat = GenerateAuditScopeReportRequest.Types.AuditScopeReportFormat.Unspecified;
            // Make the request
#pragma warning disable CS0612
            AuditScopeReport response = auditManagerClient.GenerateAuditScopeReport(scope, complianceStandard, reportFormat);
#pragma warning restore CS0612

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
GenerateAuditScopeReportRequest request = new GenerateAuditScopeReportRequest
{
    Scope = "",
    ReportFormat = GenerateAuditScopeReportRequest.Types.AuditScopeReportFormat.Unspecified,
    ComplianceFramework = "",
};
// Make the request
AuditScopeReport response = await auditManagerClient.GenerateAuditScopeReportAsync(request);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
GenerateAuditScopeReportRequest request = new GenerateAuditScopeReportRequest
{
    Scope = "",
    ReportFormat = GenerateAuditScopeReportRequest.Types.AuditScopeReportFormat.Unspecified,
    ComplianceFramework = "",
};
// Make the request
AuditScopeReport response = await auditManagerClient.GenerateAuditScopeReportAsync(request);

            // Create client
            AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
            // Initialize request argument(s)
            string scope = "";
            string complianceStandard = "";
            GenerateAuditScopeReportRequest.Types.AuditScopeReportFormat reportFormat = GenerateAuditScopeReportRequest.Types.AuditScopeReportFormat.Unspecified;
            // Make the request
#pragma warning disable CS0612
            AuditScopeReport response = await auditManagerClient.GenerateAuditScopeReportAsync(scope, complianceStandard, reportFormat);
#pragma warning restore CS0612

            // Create client
            AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
            // Initialize request argument(s)
            string scope = "";
            string complianceStandard = "";
            GenerateAuditScopeReportRequest.Types.AuditScopeReportFormat reportFormat = GenerateAuditScopeReportRequest.Types.AuditScopeReportFormat.Unspecified;
            // Make the request
#pragma warning disable CS0612
            AuditScopeReport response = await auditManagerClient.GenerateAuditScopeReportAsync(scope, complianceStandard, reportFormat);
#pragma warning restore CS0612

// Create client
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
AuditReportName name = AuditReportName.FromProjectLocationAuditReport("[PROJECT]", "[LOCATION]", "[AUDIT_REPORT]");
// Make the request
AuditReport response = auditManagerClient.GetAuditReport(name);

// Create client
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
GetAuditReportRequest request = new GetAuditReportRequest
{
    AuditReportName = AuditReportName.FromProjectLocationAuditReport("[PROJECT]", "[LOCATION]", "[AUDIT_REPORT]"),
};
// Make the request
AuditReport response = auditManagerClient.GetAuditReport(request);

// Create client
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/auditReports/[AUDIT_REPORT]";
// Make the request
AuditReport response = auditManagerClient.GetAuditReport(name);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
AuditReportName name = AuditReportName.FromProjectLocationAuditReport("[PROJECT]", "[LOCATION]", "[AUDIT_REPORT]");
// Make the request
AuditReport response = await auditManagerClient.GetAuditReportAsync(name);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
AuditReportName name = AuditReportName.FromProjectLocationAuditReport("[PROJECT]", "[LOCATION]", "[AUDIT_REPORT]");
// Make the request
AuditReport response = await auditManagerClient.GetAuditReportAsync(name);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
GetAuditReportRequest request = new GetAuditReportRequest
{
    AuditReportName = AuditReportName.FromProjectLocationAuditReport("[PROJECT]", "[LOCATION]", "[AUDIT_REPORT]"),
};
// Make the request
AuditReport response = await auditManagerClient.GetAuditReportAsync(request);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
GetAuditReportRequest request = new GetAuditReportRequest
{
    AuditReportName = AuditReportName.FromProjectLocationAuditReport("[PROJECT]", "[LOCATION]", "[AUDIT_REPORT]"),
};
// Make the request
AuditReport response = await auditManagerClient.GetAuditReportAsync(request);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/auditReports/[AUDIT_REPORT]";
// Make the request
AuditReport response = await auditManagerClient.GetAuditReportAsync(name);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/auditReports/[AUDIT_REPORT]";
// Make the request
AuditReport response = await auditManagerClient.GetAuditReportAsync(name);

// Create client
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
GetResourceEnrollmentStatusRequest request = new GetResourceEnrollmentStatusRequest
{
    ResourceEnrollmentStatusName = ResourceEnrollmentStatusName.FromFolderLocationResourceEnrollmentStatus("[FOLDER]", "[LOCATION]", "[RESOURCE_ENROLLMENT_STATUS]"),
};
// Make the request
ResourceEnrollmentStatus response = auditManagerClient.GetResourceEnrollmentStatus(request);

// Create client
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
ResourceEnrollmentStatusName name = ResourceEnrollmentStatusName.FromFolderLocationResourceEnrollmentStatus("[FOLDER]", "[LOCATION]", "[RESOURCE_ENROLLMENT_STATUS]");
// Make the request
ResourceEnrollmentStatus response = auditManagerClient.GetResourceEnrollmentStatus(name);

// Create client
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
string name = "folders/[FOLDER]/locations/[LOCATION]/resourceEnrollmentStatuses/[RESOURCE_ENROLLMENT_STATUS]";
// Make the request
ResourceEnrollmentStatus response = auditManagerClient.GetResourceEnrollmentStatus(name);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
GetResourceEnrollmentStatusRequest request = new GetResourceEnrollmentStatusRequest
{
    ResourceEnrollmentStatusName = ResourceEnrollmentStatusName.FromFolderLocationResourceEnrollmentStatus("[FOLDER]", "[LOCATION]", "[RESOURCE_ENROLLMENT_STATUS]"),
};
// Make the request
ResourceEnrollmentStatus response = await auditManagerClient.GetResourceEnrollmentStatusAsync(request);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
GetResourceEnrollmentStatusRequest request = new GetResourceEnrollmentStatusRequest
{
    ResourceEnrollmentStatusName = ResourceEnrollmentStatusName.FromFolderLocationResourceEnrollmentStatus("[FOLDER]", "[LOCATION]", "[RESOURCE_ENROLLMENT_STATUS]"),
};
// Make the request
ResourceEnrollmentStatus response = await auditManagerClient.GetResourceEnrollmentStatusAsync(request);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
ResourceEnrollmentStatusName name = ResourceEnrollmentStatusName.FromFolderLocationResourceEnrollmentStatus("[FOLDER]", "[LOCATION]", "[RESOURCE_ENROLLMENT_STATUS]");
// Make the request
ResourceEnrollmentStatus response = await auditManagerClient.GetResourceEnrollmentStatusAsync(name);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
ResourceEnrollmentStatusName name = ResourceEnrollmentStatusName.FromFolderLocationResourceEnrollmentStatus("[FOLDER]", "[LOCATION]", "[RESOURCE_ENROLLMENT_STATUS]");
// Make the request
ResourceEnrollmentStatus response = await auditManagerClient.GetResourceEnrollmentStatusAsync(name);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "folders/[FOLDER]/locations/[LOCATION]/resourceEnrollmentStatuses/[RESOURCE_ENROLLMENT_STATUS]";
// Make the request
ResourceEnrollmentStatus response = await auditManagerClient.GetResourceEnrollmentStatusAsync(name);

// Create client
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "folders/[FOLDER]/locations/[LOCATION]/resourceEnrollmentStatuses/[RESOURCE_ENROLLMENT_STATUS]";
// Make the request
ResourceEnrollmentStatus response = await auditManagerClient.GetResourceEnrollmentStatusAsync(name);

// Create client
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAuditReportsResponse, AuditReport> response = auditManagerClient.ListAuditReports(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AuditReport 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 (ListAuditReportsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AuditReport 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<AuditReport> 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 (AuditReport 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
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
EnrollmentStatusScopeName parent = EnrollmentStatusScopeName.FromFolderLocation("[FOLDER]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAuditReportsResponse, AuditReport> response = auditManagerClient.ListAuditReports(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AuditReport 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 (ListAuditReportsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AuditReport 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<AuditReport> 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 (AuditReport 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
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
FolderLocationName parent = FolderLocationName.FromFolderLocation("[FOLDER]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAuditReportsResponse, AuditReport> response = auditManagerClient.ListAuditReports(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AuditReport 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 (ListAuditReportsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AuditReport 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<AuditReport> 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 (AuditReport 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
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
ListAuditReportsRequest request = new ListAuditReportsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListAuditReportsResponse, AuditReport> response = auditManagerClient.ListAuditReports(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (AuditReport 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 (ListAuditReportsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AuditReport 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<AuditReport> 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 (AuditReport 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
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
OrganizationLocationName parent = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAuditReportsResponse, AuditReport> response = auditManagerClient.ListAuditReports(parent);

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

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

// Iterate over all response items, lazily performing RPCs as required
await foreach (AuditReport 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 (ListAuditReportsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AuditReport 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<AuditReport> 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 (AuditReport 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
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
EnrollmentStatusScopeName parent = EnrollmentStatusScopeName.FromFolderLocation("[FOLDER]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListAuditReportsResponse, AuditReport> response = auditManagerClient.ListAuditReportsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await foreach (AuditReport 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 (ListAuditReportsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AuditReport 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<AuditReport> 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 (AuditReport 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
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
FolderLocationName parent = FolderLocationName.FromFolderLocation("[FOLDER]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListAuditReportsResponse, AuditReport> response = auditManagerClient.ListAuditReportsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await foreach (AuditReport 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 (ListAuditReportsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AuditReport 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<AuditReport> 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 (AuditReport 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
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
ListAuditReportsRequest request = new ListAuditReportsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListAuditReportsResponse, AuditReport> response = auditManagerClient.ListAuditReportsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await foreach (AuditReport 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 (ListAuditReportsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AuditReport 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<AuditReport> 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 (AuditReport 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
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
OrganizationLocationName parent = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListAuditReportsResponse, AuditReport> response = auditManagerClient.ListAuditReportsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await foreach (AuditReport 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 (ListAuditReportsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AuditReport 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<AuditReport> 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 (AuditReport 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
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListAuditReportsResponse, AuditReport> response = auditManagerClient.ListAuditReportsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await foreach (AuditReport 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 (ListAuditReportsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AuditReport 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<AuditReport> 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 (AuditReport 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
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
ListControlsRequest request = new ListControlsRequest
{
    ParentAsStandardName = StandardName.FromProjectLocationStandard("[PROJECT]", "[LOCATION]", "[STANDARD]"),
};
// Make the request
PagedEnumerable<ListControlsResponse, Control> response = auditManagerClient.ListControls(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Control 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 (ListControlsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Control 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<Control> 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 (Control 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
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
StandardName parent = StandardName.FromProjectLocationStandard("[PROJECT]", "[LOCATION]", "[STANDARD]");
// Make the request
PagedEnumerable<ListControlsResponse, Control> response = auditManagerClient.ListControls(parent);

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

// Iterate over all response items, lazily performing RPCs as required
foreach (Control 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 (ListControlsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Control 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<Control> 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 (Control 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
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
ListControlsRequest request = new ListControlsRequest
{
    ParentAsStandardName = StandardName.FromProjectLocationStandard("[PROJECT]", "[LOCATION]", "[STANDARD]"),
};
// Make the request
PagedAsyncEnumerable<ListControlsResponse, Control> response = auditManagerClient.ListControlsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await foreach (Control 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 (ListControlsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Control 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<Control> 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 (Control 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
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
StandardName parent = StandardName.FromProjectLocationStandard("[PROJECT]", "[LOCATION]", "[STANDARD]");
// Make the request
PagedAsyncEnumerable<ListControlsResponse, Control> response = auditManagerClient.ListControlsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await foreach (Control 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 (ListControlsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Control 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<Control> 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 (Control 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
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/standards/[STANDARD]";
// Make the request
PagedAsyncEnumerable<ListControlsResponse, Control> response = auditManagerClient.ListControlsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await foreach (Control 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 (ListControlsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Control 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<Control> 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 (Control 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
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
EnrollmentStatusScopeName parent = EnrollmentStatusScopeName.FromFolderLocation("[FOLDER]", "[LOCATION]");
// Make the request
PagedEnumerable<ListResourceEnrollmentStatusesResponse, ResourceEnrollmentStatus> response = auditManagerClient.ListResourceEnrollmentStatuses(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ResourceEnrollmentStatus 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 (ListResourceEnrollmentStatusesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ResourceEnrollmentStatus 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<ResourceEnrollmentStatus> 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 (ResourceEnrollmentStatus 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
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
ListResourceEnrollmentStatusesRequest request = new ListResourceEnrollmentStatusesRequest
{
    ParentAsEnrollmentStatusScopeName = EnrollmentStatusScopeName.FromFolderLocation("[FOLDER]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListResourceEnrollmentStatusesResponse, ResourceEnrollmentStatus> response = auditManagerClient.ListResourceEnrollmentStatuses(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (ResourceEnrollmentStatus 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 (ListResourceEnrollmentStatusesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ResourceEnrollmentStatus 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<ResourceEnrollmentStatus> 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 (ResourceEnrollmentStatus 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
AuditManagerClient auditManagerClient = AuditManagerClient.Create();
// Initialize request argument(s)
string parent = "folders/[FOLDER]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListResourceEnrollmentStatusesResponse, ResourceEnrollmentStatus> response = auditManagerClient.ListResourceEnrollmentStatuses(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ResourceEnrollmentStatus 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 (ListResourceEnrollmentStatusesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ResourceEnrollmentStatus 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<ResourceEnrollmentStatus> 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 (ResourceEnrollmentStatus 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
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
EnrollmentStatusScopeName parent = EnrollmentStatusScopeName.FromFolderLocation("[FOLDER]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListResourceEnrollmentStatusesResponse, ResourceEnrollmentStatus> response = auditManagerClient.ListResourceEnrollmentStatusesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await foreach (ResourceEnrollmentStatus 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 (ListResourceEnrollmentStatusesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ResourceEnrollmentStatus 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<ResourceEnrollmentStatus> 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 (ResourceEnrollmentStatus 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
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
ListResourceEnrollmentStatusesRequest request = new ListResourceEnrollmentStatusesRequest
{
    ParentAsEnrollmentStatusScopeName = EnrollmentStatusScopeName.FromFolderLocation("[FOLDER]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListResourceEnrollmentStatusesResponse, ResourceEnrollmentStatus> response = auditManagerClient.ListResourceEnrollmentStatusesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await foreach (ResourceEnrollmentStatus 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 (ListResourceEnrollmentStatusesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ResourceEnrollmentStatus 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<ResourceEnrollmentStatus> 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 (ResourceEnrollmentStatus 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
AuditManagerClient auditManagerClient = await AuditManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "folders/[FOLDER]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListResourceEnrollmentStatusesResponse, ResourceEnrollmentStatus> response = auditManagerClient.ListResourceEnrollmentStatusesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await foreach (ResourceEnrollmentStatus 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 (ListResourceEnrollmentStatusesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ResourceEnrollmentStatus 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<ResourceEnrollmentStatus> 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 (ResourceEnrollmentStatus 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;