aiplatform/apiv1/auxiliary.go - gocloud - Git at Google

 // Copyright 2024 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 // Code generated by protoc-gen-go_gapic. DO NOT EDIT.

 package aiplatform

 import (
 	"context"
 	"time"

 	aiplatformpb "cloud.google.com/go/aiplatform/apiv1/aiplatformpb"
 	"cloud.google.com/go/longrunning"
 	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"
 	gax "github.com/googleapis/gax-go/v2"
 	"google.golang.org/api/iterator"
 	locationpb "google.golang.org/genproto/googleapis/cloud/location"
 )

 // AssignNotebookRuntimeOperation manages a long-running operation from AssignNotebookRuntime.
 type AssignNotebookRuntimeOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *AssignNotebookRuntimeOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.NotebookRuntime, error) {
 	var resp aiplatformpb.NotebookRuntime
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *AssignNotebookRuntimeOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.NotebookRuntime, error) {
 	var resp aiplatformpb.NotebookRuntime
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *AssignNotebookRuntimeOperation) Metadata() (*aiplatformpb.AssignNotebookRuntimeOperationMetadata, error) {
 	var meta aiplatformpb.AssignNotebookRuntimeOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *AssignNotebookRuntimeOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *AssignNotebookRuntimeOperation) Name() string {
 	return op.lro.Name()
 }

 // BatchCancelPipelineJobsOperation manages a long-running operation from BatchCancelPipelineJobs.
 type BatchCancelPipelineJobsOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *BatchCancelPipelineJobsOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.BatchCancelPipelineJobsResponse, error) {
 	var resp aiplatformpb.BatchCancelPipelineJobsResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *BatchCancelPipelineJobsOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.BatchCancelPipelineJobsResponse, error) {
 	var resp aiplatformpb.BatchCancelPipelineJobsResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *BatchCancelPipelineJobsOperation) Metadata() (*aiplatformpb.BatchCancelPipelineJobsOperationMetadata, error) {
 	var meta aiplatformpb.BatchCancelPipelineJobsOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *BatchCancelPipelineJobsOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *BatchCancelPipelineJobsOperation) Name() string {
 	return op.lro.Name()
 }

 // BatchCreateFeaturesOperation manages a long-running operation from BatchCreateFeatures.
 type BatchCreateFeaturesOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *BatchCreateFeaturesOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.BatchCreateFeaturesResponse, error) {
 	var resp aiplatformpb.BatchCreateFeaturesResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *BatchCreateFeaturesOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.BatchCreateFeaturesResponse, error) {
 	var resp aiplatformpb.BatchCreateFeaturesResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *BatchCreateFeaturesOperation) Metadata() (*aiplatformpb.BatchCreateFeaturesOperationMetadata, error) {
 	var meta aiplatformpb.BatchCreateFeaturesOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *BatchCreateFeaturesOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *BatchCreateFeaturesOperation) Name() string {
 	return op.lro.Name()
 }

 // BatchDeletePipelineJobsOperation manages a long-running operation from BatchDeletePipelineJobs.
 type BatchDeletePipelineJobsOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *BatchDeletePipelineJobsOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.BatchDeletePipelineJobsResponse, error) {
 	var resp aiplatformpb.BatchDeletePipelineJobsResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *BatchDeletePipelineJobsOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.BatchDeletePipelineJobsResponse, error) {
 	var resp aiplatformpb.BatchDeletePipelineJobsResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *BatchDeletePipelineJobsOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *BatchDeletePipelineJobsOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *BatchDeletePipelineJobsOperation) Name() string {
 	return op.lro.Name()
 }

 // BatchMigrateResourcesOperation manages a long-running operation from BatchMigrateResources.
 type BatchMigrateResourcesOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *BatchMigrateResourcesOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.BatchMigrateResourcesResponse, error) {
 	var resp aiplatformpb.BatchMigrateResourcesResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *BatchMigrateResourcesOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.BatchMigrateResourcesResponse, error) {
 	var resp aiplatformpb.BatchMigrateResourcesResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *BatchMigrateResourcesOperation) Metadata() (*aiplatformpb.BatchMigrateResourcesOperationMetadata, error) {
 	var meta aiplatformpb.BatchMigrateResourcesOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *BatchMigrateResourcesOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *BatchMigrateResourcesOperation) Name() string {
 	return op.lro.Name()
 }

 // BatchReadFeatureValuesOperation manages a long-running operation from BatchReadFeatureValues.
 type BatchReadFeatureValuesOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *BatchReadFeatureValuesOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.BatchReadFeatureValuesResponse, error) {
 	var resp aiplatformpb.BatchReadFeatureValuesResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *BatchReadFeatureValuesOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.BatchReadFeatureValuesResponse, error) {
 	var resp aiplatformpb.BatchReadFeatureValuesResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *BatchReadFeatureValuesOperation) Metadata() (*aiplatformpb.BatchReadFeatureValuesOperationMetadata, error) {
 	var meta aiplatformpb.BatchReadFeatureValuesOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *BatchReadFeatureValuesOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *BatchReadFeatureValuesOperation) Name() string {
 	return op.lro.Name()
 }

 // CheckTrialEarlyStoppingStateOperation manages a long-running operation from CheckTrialEarlyStoppingState.
 type CheckTrialEarlyStoppingStateOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CheckTrialEarlyStoppingStateOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.CheckTrialEarlyStoppingStateResponse, error) {
 	var resp aiplatformpb.CheckTrialEarlyStoppingStateResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CheckTrialEarlyStoppingStateOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.CheckTrialEarlyStoppingStateResponse, error) {
 	var resp aiplatformpb.CheckTrialEarlyStoppingStateResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CheckTrialEarlyStoppingStateOperation) Metadata() (*aiplatformpb.CheckTrialEarlyStoppingStateMetatdata, error) {
 	var meta aiplatformpb.CheckTrialEarlyStoppingStateMetatdata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CheckTrialEarlyStoppingStateOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CheckTrialEarlyStoppingStateOperation) Name() string {
 	return op.lro.Name()
 }

 // CopyModelOperation manages a long-running operation from CopyModel.
 type CopyModelOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CopyModelOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.CopyModelResponse, error) {
 	var resp aiplatformpb.CopyModelResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CopyModelOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.CopyModelResponse, error) {
 	var resp aiplatformpb.CopyModelResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CopyModelOperation) Metadata() (*aiplatformpb.CopyModelOperationMetadata, error) {
 	var meta aiplatformpb.CopyModelOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CopyModelOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CopyModelOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateDatasetOperation manages a long-running operation from CreateDataset.
 type CreateDatasetOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateDatasetOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Dataset, error) {
 	var resp aiplatformpb.Dataset
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateDatasetOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Dataset, error) {
 	var resp aiplatformpb.Dataset
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateDatasetOperation) Metadata() (*aiplatformpb.CreateDatasetOperationMetadata, error) {
 	var meta aiplatformpb.CreateDatasetOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateDatasetOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateDatasetOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateDatasetVersionOperation manages a long-running operation from CreateDatasetVersion.
 type CreateDatasetVersionOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateDatasetVersionOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DatasetVersion, error) {
 	var resp aiplatformpb.DatasetVersion
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateDatasetVersionOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DatasetVersion, error) {
 	var resp aiplatformpb.DatasetVersion
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateDatasetVersionOperation) Metadata() (*aiplatformpb.CreateDatasetVersionOperationMetadata, error) {
 	var meta aiplatformpb.CreateDatasetVersionOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateDatasetVersionOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateDatasetVersionOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateDeploymentResourcePoolOperation manages a long-running operation from CreateDeploymentResourcePool.
 type CreateDeploymentResourcePoolOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateDeploymentResourcePoolOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DeploymentResourcePool, error) {
 	var resp aiplatformpb.DeploymentResourcePool
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateDeploymentResourcePoolOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DeploymentResourcePool, error) {
 	var resp aiplatformpb.DeploymentResourcePool
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateDeploymentResourcePoolOperation) Metadata() (*aiplatformpb.CreateDeploymentResourcePoolOperationMetadata, error) {
 	var meta aiplatformpb.CreateDeploymentResourcePoolOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateDeploymentResourcePoolOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateDeploymentResourcePoolOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateEndpointOperation manages a long-running operation from CreateEndpoint.
 type CreateEndpointOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateEndpointOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Endpoint, error) {
 	var resp aiplatformpb.Endpoint
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateEndpointOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Endpoint, error) {
 	var resp aiplatformpb.Endpoint
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateEndpointOperation) Metadata() (*aiplatformpb.CreateEndpointOperationMetadata, error) {
 	var meta aiplatformpb.CreateEndpointOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateEndpointOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateEndpointOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateEntityTypeOperation manages a long-running operation from CreateEntityType.
 type CreateEntityTypeOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateEntityTypeOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.EntityType, error) {
 	var resp aiplatformpb.EntityType
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateEntityTypeOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.EntityType, error) {
 	var resp aiplatformpb.EntityType
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateEntityTypeOperation) Metadata() (*aiplatformpb.CreateEntityTypeOperationMetadata, error) {
 	var meta aiplatformpb.CreateEntityTypeOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateEntityTypeOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateEntityTypeOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateFeatureGroupOperation manages a long-running operation from CreateFeatureGroup.
 type CreateFeatureGroupOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateFeatureGroupOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureGroup, error) {
 	var resp aiplatformpb.FeatureGroup
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateFeatureGroupOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureGroup, error) {
 	var resp aiplatformpb.FeatureGroup
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateFeatureGroupOperation) Metadata() (*aiplatformpb.CreateFeatureGroupOperationMetadata, error) {
 	var meta aiplatformpb.CreateFeatureGroupOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateFeatureGroupOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateFeatureGroupOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateFeatureOnlineStoreOperation manages a long-running operation from CreateFeatureOnlineStore.
 type CreateFeatureOnlineStoreOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateFeatureOnlineStoreOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureOnlineStore, error) {
 	var resp aiplatformpb.FeatureOnlineStore
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateFeatureOnlineStoreOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureOnlineStore, error) {
 	var resp aiplatformpb.FeatureOnlineStore
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateFeatureOnlineStoreOperation) Metadata() (*aiplatformpb.CreateFeatureOnlineStoreOperationMetadata, error) {
 	var meta aiplatformpb.CreateFeatureOnlineStoreOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateFeatureOnlineStoreOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateFeatureOnlineStoreOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateFeatureOperation manages a long-running operation from CreateFeature.
 type CreateFeatureOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateFeatureOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Feature, error) {
 	var resp aiplatformpb.Feature
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateFeatureOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Feature, error) {
 	var resp aiplatformpb.Feature
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateFeatureOperation) Metadata() (*aiplatformpb.CreateFeatureOperationMetadata, error) {
 	var meta aiplatformpb.CreateFeatureOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateFeatureOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateFeatureOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateFeatureViewOperation manages a long-running operation from CreateFeatureView.
 type CreateFeatureViewOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateFeatureViewOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureView, error) {
 	var resp aiplatformpb.FeatureView
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateFeatureViewOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureView, error) {
 	var resp aiplatformpb.FeatureView
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateFeatureViewOperation) Metadata() (*aiplatformpb.CreateFeatureViewOperationMetadata, error) {
 	var meta aiplatformpb.CreateFeatureViewOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateFeatureViewOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateFeatureViewOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateFeaturestoreOperation manages a long-running operation from CreateFeaturestore.
 type CreateFeaturestoreOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateFeaturestoreOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Featurestore, error) {
 	var resp aiplatformpb.Featurestore
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateFeaturestoreOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Featurestore, error) {
 	var resp aiplatformpb.Featurestore
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateFeaturestoreOperation) Metadata() (*aiplatformpb.CreateFeaturestoreOperationMetadata, error) {
 	var meta aiplatformpb.CreateFeaturestoreOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateFeaturestoreOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateFeaturestoreOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateIndexEndpointOperation manages a long-running operation from CreateIndexEndpoint.
 type CreateIndexEndpointOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateIndexEndpointOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.IndexEndpoint, error) {
 	var resp aiplatformpb.IndexEndpoint
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateIndexEndpointOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.IndexEndpoint, error) {
 	var resp aiplatformpb.IndexEndpoint
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateIndexEndpointOperation) Metadata() (*aiplatformpb.CreateIndexEndpointOperationMetadata, error) {
 	var meta aiplatformpb.CreateIndexEndpointOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateIndexEndpointOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateIndexEndpointOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateIndexOperation manages a long-running operation from CreateIndex.
 type CreateIndexOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateIndexOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Index, error) {
 	var resp aiplatformpb.Index
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateIndexOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Index, error) {
 	var resp aiplatformpb.Index
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateIndexOperation) Metadata() (*aiplatformpb.CreateIndexOperationMetadata, error) {
 	var meta aiplatformpb.CreateIndexOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateIndexOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateIndexOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateMetadataStoreOperation manages a long-running operation from CreateMetadataStore.
 type CreateMetadataStoreOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateMetadataStoreOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.MetadataStore, error) {
 	var resp aiplatformpb.MetadataStore
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateMetadataStoreOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.MetadataStore, error) {
 	var resp aiplatformpb.MetadataStore
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateMetadataStoreOperation) Metadata() (*aiplatformpb.CreateMetadataStoreOperationMetadata, error) {
 	var meta aiplatformpb.CreateMetadataStoreOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateMetadataStoreOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateMetadataStoreOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateNotebookRuntimeTemplateOperation manages a long-running operation from CreateNotebookRuntimeTemplate.
 type CreateNotebookRuntimeTemplateOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateNotebookRuntimeTemplateOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.NotebookRuntimeTemplate, error) {
 	var resp aiplatformpb.NotebookRuntimeTemplate
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateNotebookRuntimeTemplateOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.NotebookRuntimeTemplate, error) {
 	var resp aiplatformpb.NotebookRuntimeTemplate
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateNotebookRuntimeTemplateOperation) Metadata() (*aiplatformpb.CreateNotebookRuntimeTemplateOperationMetadata, error) {
 	var meta aiplatformpb.CreateNotebookRuntimeTemplateOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateNotebookRuntimeTemplateOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateNotebookRuntimeTemplateOperation) Name() string {
 	return op.lro.Name()
 }

 // CreatePersistentResourceOperation manages a long-running operation from CreatePersistentResource.
 type CreatePersistentResourceOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreatePersistentResourceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PersistentResource, error) {
 	var resp aiplatformpb.PersistentResource
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreatePersistentResourceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PersistentResource, error) {
 	var resp aiplatformpb.PersistentResource
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreatePersistentResourceOperation) Metadata() (*aiplatformpb.CreatePersistentResourceOperationMetadata, error) {
 	var meta aiplatformpb.CreatePersistentResourceOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreatePersistentResourceOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreatePersistentResourceOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateSpecialistPoolOperation manages a long-running operation from CreateSpecialistPool.
 type CreateSpecialistPoolOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateSpecialistPoolOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.SpecialistPool, error) {
 	var resp aiplatformpb.SpecialistPool
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateSpecialistPoolOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.SpecialistPool, error) {
 	var resp aiplatformpb.SpecialistPool
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateSpecialistPoolOperation) Metadata() (*aiplatformpb.CreateSpecialistPoolOperationMetadata, error) {
 	var meta aiplatformpb.CreateSpecialistPoolOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateSpecialistPoolOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateSpecialistPoolOperation) Name() string {
 	return op.lro.Name()
 }

 // CreateTensorboardOperation manages a long-running operation from CreateTensorboard.
 type CreateTensorboardOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *CreateTensorboardOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Tensorboard, error) {
 	var resp aiplatformpb.Tensorboard
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *CreateTensorboardOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Tensorboard, error) {
 	var resp aiplatformpb.Tensorboard
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *CreateTensorboardOperation) Metadata() (*aiplatformpb.CreateTensorboardOperationMetadata, error) {
 	var meta aiplatformpb.CreateTensorboardOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *CreateTensorboardOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *CreateTensorboardOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteArtifactOperation manages a long-running operation from DeleteArtifact.
 type DeleteArtifactOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteArtifactOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteArtifactOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteArtifactOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteArtifactOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteArtifactOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteBatchPredictionJobOperation manages a long-running operation from DeleteBatchPredictionJob.
 type DeleteBatchPredictionJobOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteBatchPredictionJobOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteBatchPredictionJobOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteBatchPredictionJobOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteBatchPredictionJobOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteBatchPredictionJobOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteContextOperation manages a long-running operation from DeleteContext.
 type DeleteContextOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteContextOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteContextOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteContextOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteContextOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteContextOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteCustomJobOperation manages a long-running operation from DeleteCustomJob.
 type DeleteCustomJobOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteCustomJobOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteCustomJobOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteCustomJobOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteCustomJobOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteCustomJobOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteDataLabelingJobOperation manages a long-running operation from DeleteDataLabelingJob.
 type DeleteDataLabelingJobOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteDataLabelingJobOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteDataLabelingJobOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteDataLabelingJobOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteDataLabelingJobOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteDataLabelingJobOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteDatasetOperation manages a long-running operation from DeleteDataset.
 type DeleteDatasetOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteDatasetOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteDatasetOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteDatasetOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteDatasetOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteDatasetOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteDatasetVersionOperation manages a long-running operation from DeleteDatasetVersion.
 type DeleteDatasetVersionOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteDatasetVersionOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteDatasetVersionOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteDatasetVersionOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteDatasetVersionOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteDatasetVersionOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteDeploymentResourcePoolOperation manages a long-running operation from DeleteDeploymentResourcePool.
 type DeleteDeploymentResourcePoolOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteDeploymentResourcePoolOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteDeploymentResourcePoolOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteDeploymentResourcePoolOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteDeploymentResourcePoolOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteDeploymentResourcePoolOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteEndpointOperation manages a long-running operation from DeleteEndpoint.
 type DeleteEndpointOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteEndpointOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteEndpointOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteEndpointOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteEndpointOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteEndpointOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteEntityTypeOperation manages a long-running operation from DeleteEntityType.
 type DeleteEntityTypeOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteEntityTypeOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteEntityTypeOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteEntityTypeOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteEntityTypeOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteEntityTypeOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteExecutionOperation manages a long-running operation from DeleteExecution.
 type DeleteExecutionOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteExecutionOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteExecutionOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteExecutionOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteExecutionOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteExecutionOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteFeatureGroupOperation manages a long-running operation from DeleteFeatureGroup.
 type DeleteFeatureGroupOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteFeatureGroupOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteFeatureGroupOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteFeatureGroupOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteFeatureGroupOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteFeatureGroupOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteFeatureOnlineStoreOperation manages a long-running operation from DeleteFeatureOnlineStore.
 type DeleteFeatureOnlineStoreOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteFeatureOnlineStoreOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteFeatureOnlineStoreOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteFeatureOnlineStoreOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteFeatureOnlineStoreOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteFeatureOnlineStoreOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteFeatureOperation manages a long-running operation from DeleteFeature.
 type DeleteFeatureOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteFeatureOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteFeatureOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteFeatureOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteFeatureOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteFeatureOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteFeatureValuesOperation manages a long-running operation from DeleteFeatureValues.
 type DeleteFeatureValuesOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteFeatureValuesOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DeleteFeatureValuesResponse, error) {
 	var resp aiplatformpb.DeleteFeatureValuesResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteFeatureValuesOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DeleteFeatureValuesResponse, error) {
 	var resp aiplatformpb.DeleteFeatureValuesResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteFeatureValuesOperation) Metadata() (*aiplatformpb.DeleteFeatureValuesOperationMetadata, error) {
 	var meta aiplatformpb.DeleteFeatureValuesOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteFeatureValuesOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteFeatureValuesOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteFeatureViewOperation manages a long-running operation from DeleteFeatureView.
 type DeleteFeatureViewOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteFeatureViewOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteFeatureViewOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteFeatureViewOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteFeatureViewOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteFeatureViewOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteFeaturestoreOperation manages a long-running operation from DeleteFeaturestore.
 type DeleteFeaturestoreOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteFeaturestoreOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteFeaturestoreOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteFeaturestoreOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteFeaturestoreOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteFeaturestoreOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteHyperparameterTuningJobOperation manages a long-running operation from DeleteHyperparameterTuningJob.
 type DeleteHyperparameterTuningJobOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteHyperparameterTuningJobOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteHyperparameterTuningJobOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteHyperparameterTuningJobOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteHyperparameterTuningJobOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteHyperparameterTuningJobOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteIndexEndpointOperation manages a long-running operation from DeleteIndexEndpoint.
 type DeleteIndexEndpointOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteIndexEndpointOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteIndexEndpointOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteIndexEndpointOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteIndexEndpointOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteIndexEndpointOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteIndexOperation manages a long-running operation from DeleteIndex.
 type DeleteIndexOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteIndexOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteIndexOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteIndexOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteIndexOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteIndexOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteMetadataStoreOperation manages a long-running operation from DeleteMetadataStore.
 type DeleteMetadataStoreOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteMetadataStoreOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteMetadataStoreOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteMetadataStoreOperation) Metadata() (*aiplatformpb.DeleteMetadataStoreOperationMetadata, error) {
 	var meta aiplatformpb.DeleteMetadataStoreOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteMetadataStoreOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteMetadataStoreOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteModelDeploymentMonitoringJobOperation manages a long-running operation from DeleteModelDeploymentMonitoringJob.
 type DeleteModelDeploymentMonitoringJobOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteModelDeploymentMonitoringJobOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteModelDeploymentMonitoringJobOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteModelDeploymentMonitoringJobOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteModelDeploymentMonitoringJobOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteModelDeploymentMonitoringJobOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteModelOperation manages a long-running operation from DeleteModel.
 type DeleteModelOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteModelOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteModelOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteModelOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteModelOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteModelOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteModelVersionOperation manages a long-running operation from DeleteModelVersion.
 type DeleteModelVersionOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteModelVersionOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteModelVersionOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteModelVersionOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteModelVersionOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteModelVersionOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteNasJobOperation manages a long-running operation from DeleteNasJob.
 type DeleteNasJobOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteNasJobOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteNasJobOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteNasJobOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteNasJobOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteNasJobOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteNotebookRuntimeOperation manages a long-running operation from DeleteNotebookRuntime.
 type DeleteNotebookRuntimeOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteNotebookRuntimeOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteNotebookRuntimeOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteNotebookRuntimeOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteNotebookRuntimeOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteNotebookRuntimeOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteNotebookRuntimeTemplateOperation manages a long-running operation from DeleteNotebookRuntimeTemplate.
 type DeleteNotebookRuntimeTemplateOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteNotebookRuntimeTemplateOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteNotebookRuntimeTemplateOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteNotebookRuntimeTemplateOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteNotebookRuntimeTemplateOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteNotebookRuntimeTemplateOperation) Name() string {
 	return op.lro.Name()
 }

 // DeletePersistentResourceOperation manages a long-running operation from DeletePersistentResource.
 type DeletePersistentResourceOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeletePersistentResourceOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeletePersistentResourceOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeletePersistentResourceOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeletePersistentResourceOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeletePersistentResourceOperation) Name() string {
 	return op.lro.Name()
 }

 // DeletePipelineJobOperation manages a long-running operation from DeletePipelineJob.
 type DeletePipelineJobOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeletePipelineJobOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeletePipelineJobOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeletePipelineJobOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeletePipelineJobOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeletePipelineJobOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteSavedQueryOperation manages a long-running operation from DeleteSavedQuery.
 type DeleteSavedQueryOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteSavedQueryOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteSavedQueryOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteSavedQueryOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteSavedQueryOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteSavedQueryOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteScheduleOperation manages a long-running operation from DeleteSchedule.
 type DeleteScheduleOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteScheduleOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteScheduleOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteScheduleOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteScheduleOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteScheduleOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteSpecialistPoolOperation manages a long-running operation from DeleteSpecialistPool.
 type DeleteSpecialistPoolOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteSpecialistPoolOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteSpecialistPoolOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteSpecialistPoolOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteSpecialistPoolOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteSpecialistPoolOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteTensorboardExperimentOperation manages a long-running operation from DeleteTensorboardExperiment.
 type DeleteTensorboardExperimentOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteTensorboardExperimentOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteTensorboardExperimentOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteTensorboardExperimentOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteTensorboardExperimentOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteTensorboardExperimentOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteTensorboardOperation manages a long-running operation from DeleteTensorboard.
 type DeleteTensorboardOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteTensorboardOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteTensorboardOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteTensorboardOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteTensorboardOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteTensorboardOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteTensorboardRunOperation manages a long-running operation from DeleteTensorboardRun.
 type DeleteTensorboardRunOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteTensorboardRunOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteTensorboardRunOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteTensorboardRunOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteTensorboardRunOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteTensorboardRunOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteTensorboardTimeSeriesOperation manages a long-running operation from DeleteTensorboardTimeSeries.
 type DeleteTensorboardTimeSeriesOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteTensorboardTimeSeriesOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteTensorboardTimeSeriesOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteTensorboardTimeSeriesOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteTensorboardTimeSeriesOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteTensorboardTimeSeriesOperation) Name() string {
 	return op.lro.Name()
 }

 // DeleteTrainingPipelineOperation manages a long-running operation from DeleteTrainingPipeline.
 type DeleteTrainingPipelineOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeleteTrainingPipelineOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.WaitWithInterval(ctx, nil, time.Minute, opts...)
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeleteTrainingPipelineOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
 	return op.lro.Poll(ctx, nil, opts...)
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeleteTrainingPipelineOperation) Metadata() (*aiplatformpb.DeleteOperationMetadata, error) {
 	var meta aiplatformpb.DeleteOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeleteTrainingPipelineOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeleteTrainingPipelineOperation) Name() string {
 	return op.lro.Name()
 }

 // DeployIndexOperation manages a long-running operation from DeployIndex.
 type DeployIndexOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeployIndexOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DeployIndexResponse, error) {
 	var resp aiplatformpb.DeployIndexResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeployIndexOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DeployIndexResponse, error) {
 	var resp aiplatformpb.DeployIndexResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeployIndexOperation) Metadata() (*aiplatformpb.DeployIndexOperationMetadata, error) {
 	var meta aiplatformpb.DeployIndexOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeployIndexOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeployIndexOperation) Name() string {
 	return op.lro.Name()
 }

 // DeployModelOperation manages a long-running operation from DeployModel.
 type DeployModelOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *DeployModelOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DeployModelResponse, error) {
 	var resp aiplatformpb.DeployModelResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *DeployModelOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DeployModelResponse, error) {
 	var resp aiplatformpb.DeployModelResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *DeployModelOperation) Metadata() (*aiplatformpb.DeployModelOperationMetadata, error) {
 	var meta aiplatformpb.DeployModelOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *DeployModelOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *DeployModelOperation) Name() string {
 	return op.lro.Name()
 }

 // ExportDataOperation manages a long-running operation from ExportData.
 type ExportDataOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *ExportDataOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ExportDataResponse, error) {
 	var resp aiplatformpb.ExportDataResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *ExportDataOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ExportDataResponse, error) {
 	var resp aiplatformpb.ExportDataResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *ExportDataOperation) Metadata() (*aiplatformpb.ExportDataOperationMetadata, error) {
 	var meta aiplatformpb.ExportDataOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *ExportDataOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *ExportDataOperation) Name() string {
 	return op.lro.Name()
 }

 // ExportFeatureValuesOperation manages a long-running operation from ExportFeatureValues.
 type ExportFeatureValuesOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *ExportFeatureValuesOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ExportFeatureValuesResponse, error) {
 	var resp aiplatformpb.ExportFeatureValuesResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *ExportFeatureValuesOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ExportFeatureValuesResponse, error) {
 	var resp aiplatformpb.ExportFeatureValuesResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *ExportFeatureValuesOperation) Metadata() (*aiplatformpb.ExportFeatureValuesOperationMetadata, error) {
 	var meta aiplatformpb.ExportFeatureValuesOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *ExportFeatureValuesOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *ExportFeatureValuesOperation) Name() string {
 	return op.lro.Name()
 }

 // ExportModelOperation manages a long-running operation from ExportModel.
 type ExportModelOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *ExportModelOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ExportModelResponse, error) {
 	var resp aiplatformpb.ExportModelResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *ExportModelOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ExportModelResponse, error) {
 	var resp aiplatformpb.ExportModelResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *ExportModelOperation) Metadata() (*aiplatformpb.ExportModelOperationMetadata, error) {
 	var meta aiplatformpb.ExportModelOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *ExportModelOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *ExportModelOperation) Name() string {
 	return op.lro.Name()
 }

 // ImportDataOperation manages a long-running operation from ImportData.
 type ImportDataOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *ImportDataOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ImportDataResponse, error) {
 	var resp aiplatformpb.ImportDataResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *ImportDataOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ImportDataResponse, error) {
 	var resp aiplatformpb.ImportDataResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *ImportDataOperation) Metadata() (*aiplatformpb.ImportDataOperationMetadata, error) {
 	var meta aiplatformpb.ImportDataOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *ImportDataOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *ImportDataOperation) Name() string {
 	return op.lro.Name()
 }

 // ImportFeatureValuesOperation manages a long-running operation from ImportFeatureValues.
 type ImportFeatureValuesOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *ImportFeatureValuesOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ImportFeatureValuesResponse, error) {
 	var resp aiplatformpb.ImportFeatureValuesResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *ImportFeatureValuesOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ImportFeatureValuesResponse, error) {
 	var resp aiplatformpb.ImportFeatureValuesResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *ImportFeatureValuesOperation) Metadata() (*aiplatformpb.ImportFeatureValuesOperationMetadata, error) {
 	var meta aiplatformpb.ImportFeatureValuesOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *ImportFeatureValuesOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *ImportFeatureValuesOperation) Name() string {
 	return op.lro.Name()
 }

 // MutateDeployedIndexOperation manages a long-running operation from MutateDeployedIndex.
 type MutateDeployedIndexOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *MutateDeployedIndexOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.MutateDeployedIndexResponse, error) {
 	var resp aiplatformpb.MutateDeployedIndexResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *MutateDeployedIndexOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.MutateDeployedIndexResponse, error) {
 	var resp aiplatformpb.MutateDeployedIndexResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *MutateDeployedIndexOperation) Metadata() (*aiplatformpb.MutateDeployedIndexOperationMetadata, error) {
 	var meta aiplatformpb.MutateDeployedIndexOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *MutateDeployedIndexOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *MutateDeployedIndexOperation) Name() string {
 	return op.lro.Name()
 }

 // MutateDeployedModelOperation manages a long-running operation from MutateDeployedModel.
 type MutateDeployedModelOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *MutateDeployedModelOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.MutateDeployedModelResponse, error) {
 	var resp aiplatformpb.MutateDeployedModelResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *MutateDeployedModelOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.MutateDeployedModelResponse, error) {
 	var resp aiplatformpb.MutateDeployedModelResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *MutateDeployedModelOperation) Metadata() (*aiplatformpb.MutateDeployedModelOperationMetadata, error) {
 	var meta aiplatformpb.MutateDeployedModelOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *MutateDeployedModelOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *MutateDeployedModelOperation) Name() string {
 	return op.lro.Name()
 }

 // PurgeArtifactsOperation manages a long-running operation from PurgeArtifacts.
 type PurgeArtifactsOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *PurgeArtifactsOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PurgeArtifactsResponse, error) {
 	var resp aiplatformpb.PurgeArtifactsResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *PurgeArtifactsOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PurgeArtifactsResponse, error) {
 	var resp aiplatformpb.PurgeArtifactsResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *PurgeArtifactsOperation) Metadata() (*aiplatformpb.PurgeArtifactsMetadata, error) {
 	var meta aiplatformpb.PurgeArtifactsMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *PurgeArtifactsOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *PurgeArtifactsOperation) Name() string {
 	return op.lro.Name()
 }

 // PurgeContextsOperation manages a long-running operation from PurgeContexts.
 type PurgeContextsOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *PurgeContextsOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PurgeContextsResponse, error) {
 	var resp aiplatformpb.PurgeContextsResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *PurgeContextsOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PurgeContextsResponse, error) {
 	var resp aiplatformpb.PurgeContextsResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *PurgeContextsOperation) Metadata() (*aiplatformpb.PurgeContextsMetadata, error) {
 	var meta aiplatformpb.PurgeContextsMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *PurgeContextsOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *PurgeContextsOperation) Name() string {
 	return op.lro.Name()
 }

 // PurgeExecutionsOperation manages a long-running operation from PurgeExecutions.
 type PurgeExecutionsOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *PurgeExecutionsOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PurgeExecutionsResponse, error) {
 	var resp aiplatformpb.PurgeExecutionsResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *PurgeExecutionsOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PurgeExecutionsResponse, error) {
 	var resp aiplatformpb.PurgeExecutionsResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *PurgeExecutionsOperation) Metadata() (*aiplatformpb.PurgeExecutionsMetadata, error) {
 	var meta aiplatformpb.PurgeExecutionsMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *PurgeExecutionsOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *PurgeExecutionsOperation) Name() string {
 	return op.lro.Name()
 }

 // RebootPersistentResourceOperation manages a long-running operation from RebootPersistentResource.
 type RebootPersistentResourceOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *RebootPersistentResourceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PersistentResource, error) {
 	var resp aiplatformpb.PersistentResource
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *RebootPersistentResourceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PersistentResource, error) {
 	var resp aiplatformpb.PersistentResource
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *RebootPersistentResourceOperation) Metadata() (*aiplatformpb.RebootPersistentResourceOperationMetadata, error) {
 	var meta aiplatformpb.RebootPersistentResourceOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *RebootPersistentResourceOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *RebootPersistentResourceOperation) Name() string {
 	return op.lro.Name()
 }

 // RestoreDatasetVersionOperation manages a long-running operation from RestoreDatasetVersion.
 type RestoreDatasetVersionOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *RestoreDatasetVersionOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DatasetVersion, error) {
 	var resp aiplatformpb.DatasetVersion
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *RestoreDatasetVersionOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.DatasetVersion, error) {
 	var resp aiplatformpb.DatasetVersion
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *RestoreDatasetVersionOperation) Metadata() (*aiplatformpb.RestoreDatasetVersionOperationMetadata, error) {
 	var meta aiplatformpb.RestoreDatasetVersionOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *RestoreDatasetVersionOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *RestoreDatasetVersionOperation) Name() string {
 	return op.lro.Name()
 }

 // StartNotebookRuntimeOperation manages a long-running operation from StartNotebookRuntime.
 type StartNotebookRuntimeOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *StartNotebookRuntimeOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.StartNotebookRuntimeResponse, error) {
 	var resp aiplatformpb.StartNotebookRuntimeResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *StartNotebookRuntimeOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.StartNotebookRuntimeResponse, error) {
 	var resp aiplatformpb.StartNotebookRuntimeResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *StartNotebookRuntimeOperation) Metadata() (*aiplatformpb.StartNotebookRuntimeOperationMetadata, error) {
 	var meta aiplatformpb.StartNotebookRuntimeOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *StartNotebookRuntimeOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *StartNotebookRuntimeOperation) Name() string {
 	return op.lro.Name()
 }

 // SuggestTrialsOperation manages a long-running operation from SuggestTrials.
 type SuggestTrialsOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *SuggestTrialsOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.SuggestTrialsResponse, error) {
 	var resp aiplatformpb.SuggestTrialsResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *SuggestTrialsOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.SuggestTrialsResponse, error) {
 	var resp aiplatformpb.SuggestTrialsResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *SuggestTrialsOperation) Metadata() (*aiplatformpb.SuggestTrialsMetadata, error) {
 	var meta aiplatformpb.SuggestTrialsMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *SuggestTrialsOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *SuggestTrialsOperation) Name() string {
 	return op.lro.Name()
 }

 // UndeployIndexOperation manages a long-running operation from UndeployIndex.
 type UndeployIndexOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UndeployIndexOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.UndeployIndexResponse, error) {
 	var resp aiplatformpb.UndeployIndexResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UndeployIndexOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.UndeployIndexResponse, error) {
 	var resp aiplatformpb.UndeployIndexResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UndeployIndexOperation) Metadata() (*aiplatformpb.UndeployIndexOperationMetadata, error) {
 	var meta aiplatformpb.UndeployIndexOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UndeployIndexOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UndeployIndexOperation) Name() string {
 	return op.lro.Name()
 }

 // UndeployModelOperation manages a long-running operation from UndeployModel.
 type UndeployModelOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UndeployModelOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.UndeployModelResponse, error) {
 	var resp aiplatformpb.UndeployModelResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UndeployModelOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.UndeployModelResponse, error) {
 	var resp aiplatformpb.UndeployModelResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UndeployModelOperation) Metadata() (*aiplatformpb.UndeployModelOperationMetadata, error) {
 	var meta aiplatformpb.UndeployModelOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UndeployModelOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UndeployModelOperation) Name() string {
 	return op.lro.Name()
 }

 // UpdateExplanationDatasetOperation manages a long-running operation from UpdateExplanationDataset.
 type UpdateExplanationDatasetOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpdateExplanationDatasetOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.UpdateExplanationDatasetResponse, error) {
 	var resp aiplatformpb.UpdateExplanationDatasetResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpdateExplanationDatasetOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.UpdateExplanationDatasetResponse, error) {
 	var resp aiplatformpb.UpdateExplanationDatasetResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpdateExplanationDatasetOperation) Metadata() (*aiplatformpb.UpdateExplanationDatasetOperationMetadata, error) {
 	var meta aiplatformpb.UpdateExplanationDatasetOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpdateExplanationDatasetOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpdateExplanationDatasetOperation) Name() string {
 	return op.lro.Name()
 }

 // UpdateFeatureGroupOperation manages a long-running operation from UpdateFeatureGroup.
 type UpdateFeatureGroupOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpdateFeatureGroupOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureGroup, error) {
 	var resp aiplatformpb.FeatureGroup
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpdateFeatureGroupOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureGroup, error) {
 	var resp aiplatformpb.FeatureGroup
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpdateFeatureGroupOperation) Metadata() (*aiplatformpb.UpdateFeatureGroupOperationMetadata, error) {
 	var meta aiplatformpb.UpdateFeatureGroupOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpdateFeatureGroupOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpdateFeatureGroupOperation) Name() string {
 	return op.lro.Name()
 }

 // UpdateFeatureOnlineStoreOperation manages a long-running operation from UpdateFeatureOnlineStore.
 type UpdateFeatureOnlineStoreOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpdateFeatureOnlineStoreOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureOnlineStore, error) {
 	var resp aiplatformpb.FeatureOnlineStore
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpdateFeatureOnlineStoreOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureOnlineStore, error) {
 	var resp aiplatformpb.FeatureOnlineStore
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpdateFeatureOnlineStoreOperation) Metadata() (*aiplatformpb.UpdateFeatureOnlineStoreOperationMetadata, error) {
 	var meta aiplatformpb.UpdateFeatureOnlineStoreOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpdateFeatureOnlineStoreOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpdateFeatureOnlineStoreOperation) Name() string {
 	return op.lro.Name()
 }

 // UpdateFeatureOperation manages a long-running operation from UpdateFeature.
 type UpdateFeatureOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpdateFeatureOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Feature, error) {
 	var resp aiplatformpb.Feature
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpdateFeatureOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Feature, error) {
 	var resp aiplatformpb.Feature
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpdateFeatureOperation) Metadata() (*aiplatformpb.UpdateFeatureOperationMetadata, error) {
 	var meta aiplatformpb.UpdateFeatureOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpdateFeatureOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpdateFeatureOperation) Name() string {
 	return op.lro.Name()
 }

 // UpdateFeatureViewOperation manages a long-running operation from UpdateFeatureView.
 type UpdateFeatureViewOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpdateFeatureViewOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureView, error) {
 	var resp aiplatformpb.FeatureView
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpdateFeatureViewOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.FeatureView, error) {
 	var resp aiplatformpb.FeatureView
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpdateFeatureViewOperation) Metadata() (*aiplatformpb.UpdateFeatureViewOperationMetadata, error) {
 	var meta aiplatformpb.UpdateFeatureViewOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpdateFeatureViewOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpdateFeatureViewOperation) Name() string {
 	return op.lro.Name()
 }

 // UpdateFeaturestoreOperation manages a long-running operation from UpdateFeaturestore.
 type UpdateFeaturestoreOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpdateFeaturestoreOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Featurestore, error) {
 	var resp aiplatformpb.Featurestore
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpdateFeaturestoreOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Featurestore, error) {
 	var resp aiplatformpb.Featurestore
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpdateFeaturestoreOperation) Metadata() (*aiplatformpb.UpdateFeaturestoreOperationMetadata, error) {
 	var meta aiplatformpb.UpdateFeaturestoreOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpdateFeaturestoreOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpdateFeaturestoreOperation) Name() string {
 	return op.lro.Name()
 }

 // UpdateIndexOperation manages a long-running operation from UpdateIndex.
 type UpdateIndexOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpdateIndexOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Index, error) {
 	var resp aiplatformpb.Index
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpdateIndexOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Index, error) {
 	var resp aiplatformpb.Index
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpdateIndexOperation) Metadata() (*aiplatformpb.UpdateIndexOperationMetadata, error) {
 	var meta aiplatformpb.UpdateIndexOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpdateIndexOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpdateIndexOperation) Name() string {
 	return op.lro.Name()
 }

 // UpdateModelDeploymentMonitoringJobOperation manages a long-running operation from UpdateModelDeploymentMonitoringJob.
 type UpdateModelDeploymentMonitoringJobOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpdateModelDeploymentMonitoringJobOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ModelDeploymentMonitoringJob, error) {
 	var resp aiplatformpb.ModelDeploymentMonitoringJob
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpdateModelDeploymentMonitoringJobOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.ModelDeploymentMonitoringJob, error) {
 	var resp aiplatformpb.ModelDeploymentMonitoringJob
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpdateModelDeploymentMonitoringJobOperation) Metadata() (*aiplatformpb.UpdateModelDeploymentMonitoringJobOperationMetadata, error) {
 	var meta aiplatformpb.UpdateModelDeploymentMonitoringJobOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpdateModelDeploymentMonitoringJobOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpdateModelDeploymentMonitoringJobOperation) Name() string {
 	return op.lro.Name()
 }

 // UpdatePersistentResourceOperation manages a long-running operation from UpdatePersistentResource.
 type UpdatePersistentResourceOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpdatePersistentResourceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PersistentResource, error) {
 	var resp aiplatformpb.PersistentResource
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpdatePersistentResourceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.PersistentResource, error) {
 	var resp aiplatformpb.PersistentResource
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpdatePersistentResourceOperation) Metadata() (*aiplatformpb.UpdatePersistentResourceOperationMetadata, error) {
 	var meta aiplatformpb.UpdatePersistentResourceOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpdatePersistentResourceOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpdatePersistentResourceOperation) Name() string {
 	return op.lro.Name()
 }

 // UpdateSpecialistPoolOperation manages a long-running operation from UpdateSpecialistPool.
 type UpdateSpecialistPoolOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpdateSpecialistPoolOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.SpecialistPool, error) {
 	var resp aiplatformpb.SpecialistPool
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpdateSpecialistPoolOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.SpecialistPool, error) {
 	var resp aiplatformpb.SpecialistPool
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpdateSpecialistPoolOperation) Metadata() (*aiplatformpb.UpdateSpecialistPoolOperationMetadata, error) {
 	var meta aiplatformpb.UpdateSpecialistPoolOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpdateSpecialistPoolOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpdateSpecialistPoolOperation) Name() string {
 	return op.lro.Name()
 }

 // UpdateTensorboardOperation manages a long-running operation from UpdateTensorboard.
 type UpdateTensorboardOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpdateTensorboardOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Tensorboard, error) {
 	var resp aiplatformpb.Tensorboard
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpdateTensorboardOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.Tensorboard, error) {
 	var resp aiplatformpb.Tensorboard
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpdateTensorboardOperation) Metadata() (*aiplatformpb.UpdateTensorboardOperationMetadata, error) {
 	var meta aiplatformpb.UpdateTensorboardOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpdateTensorboardOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpdateTensorboardOperation) Name() string {
 	return op.lro.Name()
 }

 // UpgradeNotebookRuntimeOperation manages a long-running operation from UpgradeNotebookRuntime.
 type UpgradeNotebookRuntimeOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UpgradeNotebookRuntimeOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.UpgradeNotebookRuntimeResponse, error) {
 	var resp aiplatformpb.UpgradeNotebookRuntimeResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UpgradeNotebookRuntimeOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.UpgradeNotebookRuntimeResponse, error) {
 	var resp aiplatformpb.UpgradeNotebookRuntimeResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UpgradeNotebookRuntimeOperation) Metadata() (*aiplatformpb.UpgradeNotebookRuntimeOperationMetadata, error) {
 	var meta aiplatformpb.UpgradeNotebookRuntimeOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UpgradeNotebookRuntimeOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UpgradeNotebookRuntimeOperation) Name() string {
 	return op.lro.Name()
 }

 // UploadModelOperation manages a long-running operation from UploadModel.
 type UploadModelOperation struct {
 	lro *longrunning.Operation
 }

 // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
 //
 // See documentation of Poll for error-handling information.
 func (op *UploadModelOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.UploadModelResponse, error) {
 	var resp aiplatformpb.UploadModelResponse
 	if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil {
 		return nil, err
 	}
 	return &resp, nil
 }

 // Poll fetches the latest state of the long-running operation.
 //
 // Poll also fetches the latest metadata, which can be retrieved by Metadata.
 //
 // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
 // the operation has completed with failure, the error is returned and op.Done will return true.
 // If Poll succeeds and the operation has completed successfully,
 // op.Done will return true, and the response of the operation is returned.
 // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
 func (op *UploadModelOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*aiplatformpb.UploadModelResponse, error) {
 	var resp aiplatformpb.UploadModelResponse
 	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
 		return nil, err
 	}
 	if !op.Done() {
 		return nil, nil
 	}
 	return &resp, nil
 }

 // Metadata returns metadata associated with the long-running operation.
 // Metadata itself does not contact the server, but Poll does.
 // To get the latest metadata, call this method after a successful call to Poll.
 // If the metadata is not available, the returned metadata and error are both nil.
 func (op *UploadModelOperation) Metadata() (*aiplatformpb.UploadModelOperationMetadata, error) {
 	var meta aiplatformpb.UploadModelOperationMetadata
 	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	return &meta, nil
 }

 // Done reports whether the long-running operation has completed.
 func (op *UploadModelOperation) Done() bool {
 	return op.lro.Done()
 }

 // Name returns the name of the long-running operation.
 // The name is assigned by the server and is unique within the service from which the operation is created.
 func (op *UploadModelOperation) Name() string {
 	return op.lro.Name()
 }

 // AnnotationIterator manages a stream of *aiplatformpb.Annotation.
 type AnnotationIterator struct {
 	items    []*aiplatformpb.Annotation
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Annotation, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *AnnotationIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *AnnotationIterator) Next() (*aiplatformpb.Annotation, error) {
 	var item *aiplatformpb.Annotation
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *AnnotationIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *AnnotationIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // ArtifactIterator manages a stream of *aiplatformpb.Artifact.
 type ArtifactIterator struct {
 	items    []*aiplatformpb.Artifact
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Artifact, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *ArtifactIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *ArtifactIterator) Next() (*aiplatformpb.Artifact, error) {
 	var item *aiplatformpb.Artifact
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *ArtifactIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *ArtifactIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // BatchPredictionJobIterator manages a stream of *aiplatformpb.BatchPredictionJob.
 type BatchPredictionJobIterator struct {
 	items    []*aiplatformpb.BatchPredictionJob
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.BatchPredictionJob, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *BatchPredictionJobIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *BatchPredictionJobIterator) Next() (*aiplatformpb.BatchPredictionJob, error) {
 	var item *aiplatformpb.BatchPredictionJob
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *BatchPredictionJobIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *BatchPredictionJobIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // ContextIterator manages a stream of *aiplatformpb.Context.
 type ContextIterator struct {
 	items    []*aiplatformpb.Context
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Context, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *ContextIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *ContextIterator) Next() (*aiplatformpb.Context, error) {
 	var item *aiplatformpb.Context
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *ContextIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *ContextIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // CustomJobIterator manages a stream of *aiplatformpb.CustomJob.
 type CustomJobIterator struct {
 	items    []*aiplatformpb.CustomJob
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.CustomJob, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *CustomJobIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *CustomJobIterator) Next() (*aiplatformpb.CustomJob, error) {
 	var item *aiplatformpb.CustomJob
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *CustomJobIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *CustomJobIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // DataItemIterator manages a stream of *aiplatformpb.DataItem.
 type DataItemIterator struct {
 	items    []*aiplatformpb.DataItem
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.DataItem, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *DataItemIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *DataItemIterator) Next() (*aiplatformpb.DataItem, error) {
 	var item *aiplatformpb.DataItem
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *DataItemIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *DataItemIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // DataItemViewIterator manages a stream of *aiplatformpb.DataItemView.
 type DataItemViewIterator struct {
 	items    []*aiplatformpb.DataItemView
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.DataItemView, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *DataItemViewIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *DataItemViewIterator) Next() (*aiplatformpb.DataItemView, error) {
 	var item *aiplatformpb.DataItemView
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *DataItemViewIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *DataItemViewIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // DataLabelingJobIterator manages a stream of *aiplatformpb.DataLabelingJob.
 type DataLabelingJobIterator struct {
 	items    []*aiplatformpb.DataLabelingJob
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.DataLabelingJob, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *DataLabelingJobIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *DataLabelingJobIterator) Next() (*aiplatformpb.DataLabelingJob, error) {
 	var item *aiplatformpb.DataLabelingJob
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *DataLabelingJobIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *DataLabelingJobIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // DatasetIterator manages a stream of *aiplatformpb.Dataset.
 type DatasetIterator struct {
 	items    []*aiplatformpb.Dataset
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Dataset, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *DatasetIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *DatasetIterator) Next() (*aiplatformpb.Dataset, error) {
 	var item *aiplatformpb.Dataset
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *DatasetIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *DatasetIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // DatasetVersionIterator manages a stream of *aiplatformpb.DatasetVersion.
 type DatasetVersionIterator struct {
 	items    []*aiplatformpb.DatasetVersion
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.DatasetVersion, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *DatasetVersionIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *DatasetVersionIterator) Next() (*aiplatformpb.DatasetVersion, error) {
 	var item *aiplatformpb.DatasetVersion
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *DatasetVersionIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *DatasetVersionIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // DeployedModelIterator manages a stream of *aiplatformpb.DeployedModel.
 type DeployedModelIterator struct {
 	items    []*aiplatformpb.DeployedModel
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.DeployedModel, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *DeployedModelIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *DeployedModelIterator) Next() (*aiplatformpb.DeployedModel, error) {
 	var item *aiplatformpb.DeployedModel
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *DeployedModelIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *DeployedModelIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // DeploymentResourcePoolIterator manages a stream of *aiplatformpb.DeploymentResourcePool.
 type DeploymentResourcePoolIterator struct {
 	items    []*aiplatformpb.DeploymentResourcePool
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.DeploymentResourcePool, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *DeploymentResourcePoolIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *DeploymentResourcePoolIterator) Next() (*aiplatformpb.DeploymentResourcePool, error) {
 	var item *aiplatformpb.DeploymentResourcePool
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *DeploymentResourcePoolIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *DeploymentResourcePoolIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // EndpointIterator manages a stream of *aiplatformpb.Endpoint.
 type EndpointIterator struct {
 	items    []*aiplatformpb.Endpoint
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Endpoint, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *EndpointIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *EndpointIterator) Next() (*aiplatformpb.Endpoint, error) {
 	var item *aiplatformpb.Endpoint
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *EndpointIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *EndpointIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // EntityTypeIterator manages a stream of *aiplatformpb.EntityType.
 type EntityTypeIterator struct {
 	items    []*aiplatformpb.EntityType
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.EntityType, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *EntityTypeIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *EntityTypeIterator) Next() (*aiplatformpb.EntityType, error) {
 	var item *aiplatformpb.EntityType
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *EntityTypeIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *EntityTypeIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // ExecutionIterator manages a stream of *aiplatformpb.Execution.
 type ExecutionIterator struct {
 	items    []*aiplatformpb.Execution
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Execution, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *ExecutionIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *ExecutionIterator) Next() (*aiplatformpb.Execution, error) {
 	var item *aiplatformpb.Execution
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *ExecutionIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *ExecutionIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // FeatureGroupIterator manages a stream of *aiplatformpb.FeatureGroup.
 type FeatureGroupIterator struct {
 	items    []*aiplatformpb.FeatureGroup
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.FeatureGroup, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *FeatureGroupIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *FeatureGroupIterator) Next() (*aiplatformpb.FeatureGroup, error) {
 	var item *aiplatformpb.FeatureGroup
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *FeatureGroupIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *FeatureGroupIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // FeatureIterator manages a stream of *aiplatformpb.Feature.
 type FeatureIterator struct {
 	items    []*aiplatformpb.Feature
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Feature, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *FeatureIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *FeatureIterator) Next() (*aiplatformpb.Feature, error) {
 	var item *aiplatformpb.Feature
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *FeatureIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *FeatureIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // FeatureOnlineStoreIterator manages a stream of *aiplatformpb.FeatureOnlineStore.
 type FeatureOnlineStoreIterator struct {
 	items    []*aiplatformpb.FeatureOnlineStore
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.FeatureOnlineStore, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *FeatureOnlineStoreIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *FeatureOnlineStoreIterator) Next() (*aiplatformpb.FeatureOnlineStore, error) {
 	var item *aiplatformpb.FeatureOnlineStore
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *FeatureOnlineStoreIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *FeatureOnlineStoreIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // FeatureViewIterator manages a stream of *aiplatformpb.FeatureView.
 type FeatureViewIterator struct {
 	items    []*aiplatformpb.FeatureView
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.FeatureView, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *FeatureViewIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *FeatureViewIterator) Next() (*aiplatformpb.FeatureView, error) {
 	var item *aiplatformpb.FeatureView
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *FeatureViewIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *FeatureViewIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // FeatureViewSyncIterator manages a stream of *aiplatformpb.FeatureViewSync.
 type FeatureViewSyncIterator struct {
 	items    []*aiplatformpb.FeatureViewSync
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.FeatureViewSync, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *FeatureViewSyncIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *FeatureViewSyncIterator) Next() (*aiplatformpb.FeatureViewSync, error) {
 	var item *aiplatformpb.FeatureViewSync
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *FeatureViewSyncIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *FeatureViewSyncIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // FeaturestoreIterator manages a stream of *aiplatformpb.Featurestore.
 type FeaturestoreIterator struct {
 	items    []*aiplatformpb.Featurestore
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Featurestore, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *FeaturestoreIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *FeaturestoreIterator) Next() (*aiplatformpb.Featurestore, error) {
 	var item *aiplatformpb.Featurestore
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *FeaturestoreIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *FeaturestoreIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // HyperparameterTuningJobIterator manages a stream of *aiplatformpb.HyperparameterTuningJob.
 type HyperparameterTuningJobIterator struct {
 	items    []*aiplatformpb.HyperparameterTuningJob
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.HyperparameterTuningJob, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *HyperparameterTuningJobIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *HyperparameterTuningJobIterator) Next() (*aiplatformpb.HyperparameterTuningJob, error) {
 	var item *aiplatformpb.HyperparameterTuningJob
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *HyperparameterTuningJobIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *HyperparameterTuningJobIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // IndexEndpointIterator manages a stream of *aiplatformpb.IndexEndpoint.
 type IndexEndpointIterator struct {
 	items    []*aiplatformpb.IndexEndpoint
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.IndexEndpoint, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *IndexEndpointIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *IndexEndpointIterator) Next() (*aiplatformpb.IndexEndpoint, error) {
 	var item *aiplatformpb.IndexEndpoint
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *IndexEndpointIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *IndexEndpointIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // IndexIterator manages a stream of *aiplatformpb.Index.
 type IndexIterator struct {
 	items    []*aiplatformpb.Index
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Index, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *IndexIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *IndexIterator) Next() (*aiplatformpb.Index, error) {
 	var item *aiplatformpb.Index
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *IndexIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *IndexIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // LocationIterator manages a stream of *locationpb.Location.
 type LocationIterator struct {
 	items    []*locationpb.Location
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*locationpb.Location, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *LocationIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *LocationIterator) Next() (*locationpb.Location, error) {
 	var item *locationpb.Location
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *LocationIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *LocationIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // MetadataSchemaIterator manages a stream of *aiplatformpb.MetadataSchema.
 type MetadataSchemaIterator struct {
 	items    []*aiplatformpb.MetadataSchema
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.MetadataSchema, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *MetadataSchemaIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *MetadataSchemaIterator) Next() (*aiplatformpb.MetadataSchema, error) {
 	var item *aiplatformpb.MetadataSchema
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *MetadataSchemaIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *MetadataSchemaIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // MetadataStoreIterator manages a stream of *aiplatformpb.MetadataStore.
 type MetadataStoreIterator struct {
 	items    []*aiplatformpb.MetadataStore
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.MetadataStore, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *MetadataStoreIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *MetadataStoreIterator) Next() (*aiplatformpb.MetadataStore, error) {
 	var item *aiplatformpb.MetadataStore
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *MetadataStoreIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *MetadataStoreIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // MigratableResourceIterator manages a stream of *aiplatformpb.MigratableResource.
 type MigratableResourceIterator struct {
 	items    []*aiplatformpb.MigratableResource
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.MigratableResource, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *MigratableResourceIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *MigratableResourceIterator) Next() (*aiplatformpb.MigratableResource, error) {
 	var item *aiplatformpb.MigratableResource
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *MigratableResourceIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *MigratableResourceIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // ModelDeploymentMonitoringJobIterator manages a stream of *aiplatformpb.ModelDeploymentMonitoringJob.
 type ModelDeploymentMonitoringJobIterator struct {
 	items    []*aiplatformpb.ModelDeploymentMonitoringJob
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.ModelDeploymentMonitoringJob, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *ModelDeploymentMonitoringJobIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *ModelDeploymentMonitoringJobIterator) Next() (*aiplatformpb.ModelDeploymentMonitoringJob, error) {
 	var item *aiplatformpb.ModelDeploymentMonitoringJob
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *ModelDeploymentMonitoringJobIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *ModelDeploymentMonitoringJobIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // ModelEvaluationIterator manages a stream of *aiplatformpb.ModelEvaluation.
 type ModelEvaluationIterator struct {
 	items    []*aiplatformpb.ModelEvaluation
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.ModelEvaluation, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *ModelEvaluationIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *ModelEvaluationIterator) Next() (*aiplatformpb.ModelEvaluation, error) {
 	var item *aiplatformpb.ModelEvaluation
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *ModelEvaluationIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *ModelEvaluationIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // ModelEvaluationSliceIterator manages a stream of *aiplatformpb.ModelEvaluationSlice.
 type ModelEvaluationSliceIterator struct {
 	items    []*aiplatformpb.ModelEvaluationSlice
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.ModelEvaluationSlice, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *ModelEvaluationSliceIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *ModelEvaluationSliceIterator) Next() (*aiplatformpb.ModelEvaluationSlice, error) {
 	var item *aiplatformpb.ModelEvaluationSlice
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *ModelEvaluationSliceIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *ModelEvaluationSliceIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // ModelIterator manages a stream of *aiplatformpb.Model.
 type ModelIterator struct {
 	items    []*aiplatformpb.Model
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Model, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *ModelIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *ModelIterator) Next() (*aiplatformpb.Model, error) {
 	var item *aiplatformpb.Model
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *ModelIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *ModelIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // ModelMonitoringStatsAnomaliesIterator manages a stream of *aiplatformpb.ModelMonitoringStatsAnomalies.
 type ModelMonitoringStatsAnomaliesIterator struct {
 	items    []*aiplatformpb.ModelMonitoringStatsAnomalies
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.ModelMonitoringStatsAnomalies, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *ModelMonitoringStatsAnomaliesIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *ModelMonitoringStatsAnomaliesIterator) Next() (*aiplatformpb.ModelMonitoringStatsAnomalies, error) {
 	var item *aiplatformpb.ModelMonitoringStatsAnomalies
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *ModelMonitoringStatsAnomaliesIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *ModelMonitoringStatsAnomaliesIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // NasJobIterator manages a stream of *aiplatformpb.NasJob.
 type NasJobIterator struct {
 	items    []*aiplatformpb.NasJob
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.NasJob, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *NasJobIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *NasJobIterator) Next() (*aiplatformpb.NasJob, error) {
 	var item *aiplatformpb.NasJob
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *NasJobIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *NasJobIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // NasTrialDetailIterator manages a stream of *aiplatformpb.NasTrialDetail.
 type NasTrialDetailIterator struct {
 	items    []*aiplatformpb.NasTrialDetail
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.NasTrialDetail, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *NasTrialDetailIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *NasTrialDetailIterator) Next() (*aiplatformpb.NasTrialDetail, error) {
 	var item *aiplatformpb.NasTrialDetail
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *NasTrialDetailIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *NasTrialDetailIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // NotebookRuntimeIterator manages a stream of *aiplatformpb.NotebookRuntime.
 type NotebookRuntimeIterator struct {
 	items    []*aiplatformpb.NotebookRuntime
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.NotebookRuntime, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *NotebookRuntimeIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *NotebookRuntimeIterator) Next() (*aiplatformpb.NotebookRuntime, error) {
 	var item *aiplatformpb.NotebookRuntime
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *NotebookRuntimeIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *NotebookRuntimeIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // NotebookRuntimeTemplateIterator manages a stream of *aiplatformpb.NotebookRuntimeTemplate.
 type NotebookRuntimeTemplateIterator struct {
 	items    []*aiplatformpb.NotebookRuntimeTemplate
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.NotebookRuntimeTemplate, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *NotebookRuntimeTemplateIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *NotebookRuntimeTemplateIterator) Next() (*aiplatformpb.NotebookRuntimeTemplate, error) {
 	var item *aiplatformpb.NotebookRuntimeTemplate
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *NotebookRuntimeTemplateIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *NotebookRuntimeTemplateIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // OperationIterator manages a stream of *longrunningpb.Operation.
 type OperationIterator struct {
 	items    []*longrunningpb.Operation
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*longrunningpb.Operation, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *OperationIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *OperationIterator) Next() (*longrunningpb.Operation, error) {
 	var item *longrunningpb.Operation
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *OperationIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *OperationIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // PersistentResourceIterator manages a stream of *aiplatformpb.PersistentResource.
 type PersistentResourceIterator struct {
 	items    []*aiplatformpb.PersistentResource
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.PersistentResource, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *PersistentResourceIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *PersistentResourceIterator) Next() (*aiplatformpb.PersistentResource, error) {
 	var item *aiplatformpb.PersistentResource
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *PersistentResourceIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *PersistentResourceIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // PipelineJobIterator manages a stream of *aiplatformpb.PipelineJob.
 type PipelineJobIterator struct {
 	items    []*aiplatformpb.PipelineJob
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.PipelineJob, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *PipelineJobIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *PipelineJobIterator) Next() (*aiplatformpb.PipelineJob, error) {
 	var item *aiplatformpb.PipelineJob
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *PipelineJobIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *PipelineJobIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // SavedQueryIterator manages a stream of *aiplatformpb.SavedQuery.
 type SavedQueryIterator struct {
 	items    []*aiplatformpb.SavedQuery
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.SavedQuery, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *SavedQueryIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *SavedQueryIterator) Next() (*aiplatformpb.SavedQuery, error) {
 	var item *aiplatformpb.SavedQuery
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *SavedQueryIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *SavedQueryIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // ScheduleIterator manages a stream of *aiplatformpb.Schedule.
 type ScheduleIterator struct {
 	items    []*aiplatformpb.Schedule
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Schedule, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *ScheduleIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *ScheduleIterator) Next() (*aiplatformpb.Schedule, error) {
 	var item *aiplatformpb.Schedule
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *ScheduleIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *ScheduleIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // SpecialistPoolIterator manages a stream of *aiplatformpb.SpecialistPool.
 type SpecialistPoolIterator struct {
 	items    []*aiplatformpb.SpecialistPool
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.SpecialistPool, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *SpecialistPoolIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *SpecialistPoolIterator) Next() (*aiplatformpb.SpecialistPool, error) {
 	var item *aiplatformpb.SpecialistPool
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *SpecialistPoolIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *SpecialistPoolIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // StudyIterator manages a stream of *aiplatformpb.Study.
 type StudyIterator struct {
 	items    []*aiplatformpb.Study
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Study, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *StudyIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *StudyIterator) Next() (*aiplatformpb.Study, error) {
 	var item *aiplatformpb.Study
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *StudyIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *StudyIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // TensorboardExperimentIterator manages a stream of *aiplatformpb.TensorboardExperiment.
 type TensorboardExperimentIterator struct {
 	items    []*aiplatformpb.TensorboardExperiment
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.TensorboardExperiment, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *TensorboardExperimentIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *TensorboardExperimentIterator) Next() (*aiplatformpb.TensorboardExperiment, error) {
 	var item *aiplatformpb.TensorboardExperiment
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *TensorboardExperimentIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *TensorboardExperimentIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // TensorboardIterator manages a stream of *aiplatformpb.Tensorboard.
 type TensorboardIterator struct {
 	items    []*aiplatformpb.Tensorboard
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Tensorboard, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *TensorboardIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *TensorboardIterator) Next() (*aiplatformpb.Tensorboard, error) {
 	var item *aiplatformpb.Tensorboard
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *TensorboardIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *TensorboardIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // TensorboardRunIterator manages a stream of *aiplatformpb.TensorboardRun.
 type TensorboardRunIterator struct {
 	items    []*aiplatformpb.TensorboardRun
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.TensorboardRun, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *TensorboardRunIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *TensorboardRunIterator) Next() (*aiplatformpb.TensorboardRun, error) {
 	var item *aiplatformpb.TensorboardRun
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *TensorboardRunIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *TensorboardRunIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // TensorboardTimeSeriesIterator manages a stream of *aiplatformpb.TensorboardTimeSeries.
 type TensorboardTimeSeriesIterator struct {
 	items    []*aiplatformpb.TensorboardTimeSeries
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.TensorboardTimeSeries, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *TensorboardTimeSeriesIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *TensorboardTimeSeriesIterator) Next() (*aiplatformpb.TensorboardTimeSeries, error) {
 	var item *aiplatformpb.TensorboardTimeSeries
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *TensorboardTimeSeriesIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *TensorboardTimeSeriesIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // TimeSeriesDataPointIterator manages a stream of *aiplatformpb.TimeSeriesDataPoint.
 type TimeSeriesDataPointIterator struct {
 	items    []*aiplatformpb.TimeSeriesDataPoint
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.TimeSeriesDataPoint, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *TimeSeriesDataPointIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *TimeSeriesDataPointIterator) Next() (*aiplatformpb.TimeSeriesDataPoint, error) {
 	var item *aiplatformpb.TimeSeriesDataPoint
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *TimeSeriesDataPointIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *TimeSeriesDataPointIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // TrainingPipelineIterator manages a stream of *aiplatformpb.TrainingPipeline.
 type TrainingPipelineIterator struct {
 	items    []*aiplatformpb.TrainingPipeline
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.TrainingPipeline, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *TrainingPipelineIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *TrainingPipelineIterator) Next() (*aiplatformpb.TrainingPipeline, error) {
 	var item *aiplatformpb.TrainingPipeline
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *TrainingPipelineIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *TrainingPipelineIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // TrialIterator manages a stream of *aiplatformpb.Trial.
 type TrialIterator struct {
 	items    []*aiplatformpb.Trial
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.Trial, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *TrialIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *TrialIterator) Next() (*aiplatformpb.Trial, error) {
 	var item *aiplatformpb.Trial
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *TrialIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *TrialIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }

 // TuningJobIterator manages a stream of *aiplatformpb.TuningJob.
 type TuningJobIterator struct {
 	items    []*aiplatformpb.TuningJob
 	pageInfo *iterator.PageInfo
 	nextFunc func() error

 	// Response is the raw response for the current page.
 	// It must be cast to the RPC response type.
 	// Calling Next() or InternalFetch() updates this value.
 	Response interface{}

 	// InternalFetch is for use by the Google Cloud Libraries only.
 	// It is not part of the stable interface of this package.
 	//
 	// InternalFetch returns results from a single call to the underlying RPC.
 	// The number of results is no greater than pageSize.
 	// If there are no more results, nextPageToken is empty and err is nil.
 	InternalFetch func(pageSize int, pageToken string) (results []*aiplatformpb.TuningJob, nextPageToken string, err error)
 }

 // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
 func (it *TuningJobIterator) PageInfo() *iterator.PageInfo {
 	return it.pageInfo
 }

 // Next returns the next result. Its second return value is iterator.Done if there are no more
 // results. Once Next returns Done, all subsequent calls will return Done.
 func (it *TuningJobIterator) Next() (*aiplatformpb.TuningJob, error) {
 	var item *aiplatformpb.TuningJob
 	if err := it.nextFunc(); err != nil {
 		return item, err
 	}
 	item = it.items[0]
 	it.items = it.items[1:]
 	return item, nil
 }

 func (it *TuningJobIterator) bufLen() int {
 	return len(it.items)
 }

 func (it *TuningJobIterator) takeBuf() interface{} {
 	b := it.items
 	it.items = nil
 	return b
 }