/// <summary>Snippet for DeleteProfileAsync</summary>
        public async Task DeleteProfileResourceNamesAsync()
        {
            // Snippet: DeleteProfileAsync(ProfileName, CallSettings)
            // Additional: DeleteProfileAsync(ProfileName, CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            ProfileName name = ProfileName.FromProjectTenantProfile("[PROJECT]", "[TENANT]", "[PROFILE]");
            // Make the request
            await profileServiceClient.DeleteProfileAsync(name);

            // End snippet
        }
        /// <summary>Snippet for UpdateProfileAsync</summary>
        public async Task UpdateProfileAsync()
        {
            // Snippet: UpdateProfileAsync(Profile, CallSettings)
            // Additional: UpdateProfileAsync(Profile, CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            Profile profile = new Profile();
            // Make the request
            Profile response = await profileServiceClient.UpdateProfileAsync(profile);

            // End snippet
        }
        /// <summary>Snippet for DeleteProfileAsync</summary>
        public async Task DeleteProfileAsync()
        {
            // Snippet: DeleteProfileAsync(string, CallSettings)
            // Additional: DeleteProfileAsync(string, CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            string name = "projects/[PROJECT]/tenants/[TENANT]/profiles/[PROFILE]";
            // Make the request
            await profileServiceClient.DeleteProfileAsync(name);

            // End snippet
        }
        /// <summary>Snippet for GetProfileAsync</summary>
        public async Task GetProfileAsync()
        {
            // Snippet: GetProfileAsync(string,CallSettings)
            // Additional: GetProfileAsync(string,CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            string formattedName = new ProfileName("[PROJECT]", "[COMPANY]", "[PROFILE]").ToString();
            // Make the request
            Profile response = await profileServiceClient.GetProfileAsync(formattedName);

            // End snippet
        }
        /// <summary>Snippet for ListProfiles</summary>
        public async Task ListProfilesRequestObjectAsync()
        {
            // Snippet: ListProfilesAsync(ListProfilesRequest, CallSettings)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            ListProfilesRequest request = new ListProfilesRequest
            {
                ParentAsTenantName = TenantName.FromProjectTenant("[PROJECT]", "[TENANT]"),
                ReadMask           = new FieldMask(),
                Filter             = "",
            };
            // Make the request
            PagedAsyncEnumerable <ListProfilesResponse, Profile> response = profileServiceClient.ListProfilesAsync(request);

            // Iterate over all response items, lazily performing RPCs as required
            await response.ForEachAsync((Profile 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((ListProfilesResponse page) =>
            {
                // Do something with each page of items
                Console.WriteLine("A page of results:");
                foreach (Profile 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 <Profile> 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 (Profile 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;
            // End snippet
        }
        /// <summary>Snippet for DeleteProfileAsync</summary>
        public async Task DeleteProfileAsync()
        {
            // Snippet: DeleteProfileAsync(ProfileName,CallSettings)
            // Additional: DeleteProfileAsync(ProfileName,CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            ProfileName name = new ProfileName("[PROJECT]", "[COMPANY]", "[PROFILE]");
            // Make the request
            await profileServiceClient.DeleteProfileAsync(name);

            // End snippet
        }
        /// <summary>Snippet for CreateProfileAsync</summary>
        public async Task CreateProfileResourceNamesAsync()
        {
            // Snippet: CreateProfileAsync(TenantName, Profile, CallSettings)
            // Additional: CreateProfileAsync(TenantName, Profile, CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            TenantName parent  = TenantName.FromProjectTenant("[PROJECT]", "[TENANT]");
            Profile    profile = new Profile();
            // Make the request
            Profile response = await profileServiceClient.CreateProfileAsync(parent, profile);

            // End snippet
        }
        /// <summary>Snippet for CreateProfileAsync</summary>
        public async Task CreateProfileAsync()
        {
            // Snippet: CreateProfileAsync(string, Profile, CallSettings)
            // Additional: CreateProfileAsync(string, Profile, CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            string  parent  = "projects/[PROJECT]/tenants/[TENANT]";
            Profile profile = new Profile();
            // Make the request
            Profile response = await profileServiceClient.CreateProfileAsync(parent, profile);

            // End snippet
        }
        /// <summary>Snippet for CreateProfileAsync</summary>
        public async Task CreateProfileAsync()
        {
            // Snippet: CreateProfileAsync(CompanyName,Profile,CallSettings)
            // Additional: CreateProfileAsync(CompanyName,Profile,CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            CompanyName parent  = new CompanyName("[PROJECT]", "[COMPANY]");
            Profile     profile = new Profile();
            // Make the request
            Profile response = await profileServiceClient.CreateProfileAsync(parent, profile);

            // End snippet
        }
        /// <summary>Snippet for SearchProfilesAsync</summary>
        public async Task SearchProfilesAsync_RequestObject()
        {
            // Snippet: SearchProfilesAsync(SearchProfilesRequest,CallSettings)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            SearchProfilesRequest request = new SearchProfilesRequest
            {
                ParentAsCompanyName = new CompanyName("[PROJECT]", "[COMPANY]"),
                RequestMetadata     = new RequestMetadata(),
            };
            // Make the request
            PagedAsyncEnumerable <SearchProfilesResponse, HistogramQueryResult> response =
                profileServiceClient.SearchProfilesAsync(request);

            // Iterate over all response items, lazily performing RPCs as required
            await response.ForEachAsync((HistogramQueryResult 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((SearchProfilesResponse page) =>
            {
                // Do something with each page of items
                Console.WriteLine("A page of results:");
                foreach (HistogramQueryResult item in page)
                {
                    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 <HistogramQueryResult> 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 (HistogramQueryResult item in singlePage)
            {
                Console.WriteLine(item);
            }
            // Store the pageToken, for when the next page is required.
            string nextPageToken = singlePage.NextPageToken;
            // End snippet
        }
        /// <summary>Snippet for GetProfileAsync</summary>
        public async Task GetProfileRequestObjectAsync()
        {
            // Snippet: GetProfileAsync(GetProfileRequest, CallSettings)
            // Additional: GetProfileAsync(GetProfileRequest, CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            GetProfileRequest request = new GetProfileRequest
            {
                ProfileName = ProfileName.FromProjectTenantProfile("[PROJECT]", "[TENANT]", "[PROFILE]"),
            };
            // Make the request
            Profile response = await profileServiceClient.GetProfileAsync(request);

            // End snippet
        }
        /// <summary>Snippet for UpdateProfileAsync</summary>
        public async Task UpdateProfileAsync_RequestObject()
        {
            // Snippet: UpdateProfileAsync(UpdateProfileRequest,CallSettings)
            // Additional: UpdateProfileAsync(UpdateProfileRequest,CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            UpdateProfileRequest request = new UpdateProfileRequest
            {
                Profile = new Profile(),
            };
            // Make the request
            Profile response = await profileServiceClient.UpdateProfileAsync(request);

            // End snippet
        }
        /// <summary>Snippet for DeleteProfileAsync</summary>
        public async Task DeleteProfileAsync_RequestObject()
        {
            // Snippet: DeleteProfileAsync(DeleteProfileRequest,CallSettings)
            // Additional: DeleteProfileAsync(DeleteProfileRequest,CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            DeleteProfileRequest request = new DeleteProfileRequest
            {
                Name = new ProfileName("[PROJECT]", "[COMPANY]", "[PROFILE]").ToString(),
            };
            // Make the request
            await profileServiceClient.DeleteProfileAsync(request);

            // End snippet
        }
        /// <summary>Snippet for CreateProfileAsync</summary>
        public async Task CreateProfileRequestObjectAsync()
        {
            // Snippet: CreateProfileAsync(CreateProfileRequest, CallSettings)
            // Additional: CreateProfileAsync(CreateProfileRequest, CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            CreateProfileRequest request = new CreateProfileRequest
            {
                ParentAsTenantName = TenantName.FromProjectTenant("[PROJECT]", "[TENANT]"),
                Profile            = new Profile(),
            };
            // Make the request
            Profile response = await profileServiceClient.CreateProfileAsync(request);

            // End snippet
        }
        /// <summary>Snippet for CreateProfileAsync</summary>
        public async Task CreateProfileAsync_RequestObject()
        {
            // Snippet: CreateProfileAsync(CreateProfileRequest,CallSettings)
            // Additional: CreateProfileAsync(CreateProfileRequest,CancellationToken)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            CreateProfileRequest request = new CreateProfileRequest
            {
                Parent  = new CompanyName("[PROJECT]", "[COMPANY]").ToString(),
                Profile = new Profile(),
            };
            // Make the request
            Profile response = await profileServiceClient.CreateProfileAsync(request);

            // End snippet
        }
        /// <summary>Snippet for ListProfilesAsync</summary>
        public async Task ListProfilesAsync()
        {
            // Snippet: ListProfilesAsync(string,string,int?,CallSettings)
            // Create client
            ProfileServiceClient profileServiceClient = await ProfileServiceClient.CreateAsync();

            // Initialize request argument(s)
            string formattedParent = new CompanyName("[PROJECT]", "[COMPANY]").ToString();
            // Make the request
            PagedAsyncEnumerable <ListProfilesResponse, Profile> response =
                profileServiceClient.ListProfilesAsync(formattedParent);

            // Iterate over all response items, lazily performing RPCs as required
            await response.ForEachAsync((Profile 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((ListProfilesResponse page) =>
            {
                // Do something with each page of items
                Console.WriteLine("A page of results:");
                foreach (Profile item in page)
                {
                    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 <Profile> 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 (Profile item in singlePage)
            {
                Console.WriteLine(item);
            }
            // Store the pageToken, for when the next page is required.
            string nextPageToken = singlePage.NextPageToken;
            // End snippet
        }