financialservices

package
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 11, 2026 License: Apache-2.0 Imports: 31 Imported by: 0

Documentation

Overview

Package financialservices is an auto-generated package for the Financial Services API.

General documentation

For information that is relevant for all client libraries please reference https://pkg.go.dev/cloud.google.com/go#pkg-overview. Some information on this page includes:

Example usage

To get started with this package, create a client. 

// go get cloud.google.com/go/financialservices/apiv1@latest
ctx := context.Background()
// This snippet has been automatically generated and should be regarded as a code template only.
// It will require modifications to work:
// - It may require correct/in-range values for request initialization.
// - It may require specifying regional endpoints when creating the service client as shown in:
//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
c, err := financialservices.NewAMLClient(ctx)
if err != nil {
	// TODO: Handle error.
}
defer c.Close()

The client will use your default application credentials. Clients should be reused instead of created as needed. The methods of Client are safe for concurrent use by multiple goroutines. The returned client must be Closed when it is done being used.

Using the Client

The following is an example of making an API call with the newly created client, mentioned above. 

req := &financialservicespb.CreateBacktestResultRequest{
	// TODO: Fill request struct fields.
	// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#CreateBacktestResultRequest.
}
op, err := c.CreateBacktestResult(ctx, req)
if err != nil {
	// TODO: Handle error.
}

resp, err := op.Wait(ctx)
if err != nil {
	// TODO: Handle error.
}
// TODO: Use resp.
_ = resp

Use of Context

The ctx passed to NewAMLClient is used for authentication requests and for creating the underlying connection, but is not used for subsequent calls. Individual methods on the client use the ctx given to them.

To close the open connection, use the Close() method.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func DefaultAuthScopes 

func DefaultAuthScopes() []string

DefaultAuthScopes reports the default set of authentication scopes to use with this package.

Types

type AMLCallOptions 

type AMLCallOptions struct {
	ListInstances                  []gax.CallOption
	GetInstance                    []gax.CallOption
	CreateInstance                 []gax.CallOption
	UpdateInstance                 []gax.CallOption
	DeleteInstance                 []gax.CallOption
	ImportRegisteredParties        []gax.CallOption
	ExportRegisteredParties        []gax.CallOption
	ListDatasets                   []gax.CallOption
	GetDataset                     []gax.CallOption
	CreateDataset                  []gax.CallOption
	UpdateDataset                  []gax.CallOption
	DeleteDataset                  []gax.CallOption
	ListModels                     []gax.CallOption
	GetModel                       []gax.CallOption
	CreateModel                    []gax.CallOption
	UpdateModel                    []gax.CallOption
	ExportModelMetadata            []gax.CallOption
	DeleteModel                    []gax.CallOption
	ListEngineConfigs              []gax.CallOption
	GetEngineConfig                []gax.CallOption
	CreateEngineConfig             []gax.CallOption
	UpdateEngineConfig             []gax.CallOption
	ExportEngineConfigMetadata     []gax.CallOption
	DeleteEngineConfig             []gax.CallOption
	GetEngineVersion               []gax.CallOption
	ListEngineVersions             []gax.CallOption
	ListPredictionResults          []gax.CallOption
	GetPredictionResult            []gax.CallOption
	CreatePredictionResult         []gax.CallOption
	UpdatePredictionResult         []gax.CallOption
	ExportPredictionResultMetadata []gax.CallOption
	DeletePredictionResult         []gax.CallOption
	ListBacktestResults            []gax.CallOption
	GetBacktestResult              []gax.CallOption
	CreateBacktestResult           []gax.CallOption
	UpdateBacktestResult           []gax.CallOption
	ExportBacktestResultMetadata   []gax.CallOption
	DeleteBacktestResult           []gax.CallOption
	GetLocation                    []gax.CallOption
	ListLocations                  []gax.CallOption
	CancelOperation                []gax.CallOption
	DeleteOperation                []gax.CallOption
	GetOperation                   []gax.CallOption
	ListOperations                 []gax.CallOption
}

AMLCallOptions contains the retry settings for each method of AMLClient.

type AMLClient 

type AMLClient struct {

	// The call options for this service.
	CallOptions *AMLCallOptions

	// LROClient is used internally to handle long-running operations.
	// It is exposed so that its CallOptions can be modified if required.
	// Users should not Close this client.
	LROClient *lroauto.OperationsClient
	// contains filtered or unexported fields
}

AMLClient is a client for interacting with Financial Services API. Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.

The AML (Anti Money Laundering) service allows users to perform REST operations on aml.

func NewAMLClient 

func NewAMLClient(ctx context.Context, opts ...option.ClientOption) (*AMLClient, error)

NewAMLClient creates a new aml client based on gRPC. The returned client must be Closed when it is done being used to clean up its underlying connections.

The AML (Anti Money Laundering) service allows users to perform REST operations on aml.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	// TODO: Use client.
	_ = c
}

func NewAMLRESTClient 

func NewAMLRESTClient(ctx context.Context, opts ...option.ClientOption) (*AMLClient, error)

NewAMLRESTClient creates a new aml rest client.

The AML (Anti Money Laundering) service allows users to perform REST operations on aml.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLRESTClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	// TODO: Use client.
	_ = c
}

func (*AMLClient) CancelOperation 

func (c *AMLClient) CancelOperation(ctx context.Context, req *longrunningpb.CancelOperationRequest, opts ...gax.CallOption) error

CancelOperation is a utility method from google.longrunning.Operations.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.CancelOperationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#CancelOperationRequest.
	}
	err = c.CancelOperation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*AMLClient) Close 

func (c *AMLClient) Close() error

Close closes the connection to the API service. The user should invoke this when the client is no longer required.

func (*AMLClient) Connection deprecated 

func (c *AMLClient) Connection() *grpc.ClientConn

Connection returns a connection to the API service.

Deprecated: Connections are now pooled so this method does not always return the same resource.

func (*AMLClient) CreateBacktestResult 

func (c *AMLClient) CreateBacktestResult(ctx context.Context, req *financialservicespb.CreateBacktestResultRequest, opts ...gax.CallOption) (*CreateBacktestResultOperation, error)

CreateBacktestResult create a BacktestResult.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.CreateBacktestResultRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#CreateBacktestResultRequest.
	}
	op, err := c.CreateBacktestResult(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) CreateBacktestResultOperation 

func (c *AMLClient) CreateBacktestResultOperation(name string) *CreateBacktestResultOperation

CreateBacktestResultOperation returns a new CreateBacktestResultOperation from a given name. The name must be that of a previously created CreateBacktestResultOperation, possibly from a different process.

func (*AMLClient) CreateDataset 

func (c *AMLClient) CreateDataset(ctx context.Context, req *financialservicespb.CreateDatasetRequest, opts ...gax.CallOption) (*CreateDatasetOperation, error)

CreateDataset creates a dataset.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.CreateDatasetRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#CreateDatasetRequest.
	}
	op, err := c.CreateDataset(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) CreateDatasetOperation 

func (c *AMLClient) CreateDatasetOperation(name string) *CreateDatasetOperation

CreateDatasetOperation returns a new CreateDatasetOperation from a given name. The name must be that of a previously created CreateDatasetOperation, possibly from a different process.

func (*AMLClient) CreateEngineConfig 

func (c *AMLClient) CreateEngineConfig(ctx context.Context, req *financialservicespb.CreateEngineConfigRequest, opts ...gax.CallOption) (*CreateEngineConfigOperation, error)

CreateEngineConfig creates an engine config.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.CreateEngineConfigRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#CreateEngineConfigRequest.
	}
	op, err := c.CreateEngineConfig(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) CreateEngineConfigOperation 

func (c *AMLClient) CreateEngineConfigOperation(name string) *CreateEngineConfigOperation

CreateEngineConfigOperation returns a new CreateEngineConfigOperation from a given name. The name must be that of a previously created CreateEngineConfigOperation, possibly from a different process.

func (*AMLClient) CreateInstance 

func (c *AMLClient) CreateInstance(ctx context.Context, req *financialservicespb.CreateInstanceRequest, opts ...gax.CallOption) (*CreateInstanceOperation, error)

CreateInstance creates an instance.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.CreateInstanceRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#CreateInstanceRequest.
	}
	op, err := c.CreateInstance(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) CreateInstanceOperation 

func (c *AMLClient) CreateInstanceOperation(name string) *CreateInstanceOperation

CreateInstanceOperation returns a new CreateInstanceOperation from a given name. The name must be that of a previously created CreateInstanceOperation, possibly from a different process.

func (*AMLClient) CreateModel 

func (c *AMLClient) CreateModel(ctx context.Context, req *financialservicespb.CreateModelRequest, opts ...gax.CallOption) (*CreateModelOperation, error)

CreateModel creates a model.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.CreateModelRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#CreateModelRequest.
	}
	op, err := c.CreateModel(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) CreateModelOperation 

func (c *AMLClient) CreateModelOperation(name string) *CreateModelOperation

CreateModelOperation returns a new CreateModelOperation from a given name. The name must be that of a previously created CreateModelOperation, possibly from a different process.

func (*AMLClient) CreatePredictionResult 

func (c *AMLClient) CreatePredictionResult(ctx context.Context, req *financialservicespb.CreatePredictionResultRequest, opts ...gax.CallOption) (*CreatePredictionResultOperation, error)

CreatePredictionResult create a PredictionResult.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.CreatePredictionResultRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#CreatePredictionResultRequest.
	}
	op, err := c.CreatePredictionResult(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) CreatePredictionResultOperation 

func (c *AMLClient) CreatePredictionResultOperation(name string) *CreatePredictionResultOperation

CreatePredictionResultOperation returns a new CreatePredictionResultOperation from a given name. The name must be that of a previously created CreatePredictionResultOperation, possibly from a different process.

func (*AMLClient) DeleteBacktestResult 

func (c *AMLClient) DeleteBacktestResult(ctx context.Context, req *financialservicespb.DeleteBacktestResultRequest, opts ...gax.CallOption) (*DeleteBacktestResultOperation, error)

DeleteBacktestResult deletes a BacktestResult.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.DeleteBacktestResultRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#DeleteBacktestResultRequest.
	}
	op, err := c.DeleteBacktestResult(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*AMLClient) DeleteBacktestResultOperation 

func (c *AMLClient) DeleteBacktestResultOperation(name string) *DeleteBacktestResultOperation

DeleteBacktestResultOperation returns a new DeleteBacktestResultOperation from a given name. The name must be that of a previously created DeleteBacktestResultOperation, possibly from a different process.

func (*AMLClient) DeleteDataset 

func (c *AMLClient) DeleteDataset(ctx context.Context, req *financialservicespb.DeleteDatasetRequest, opts ...gax.CallOption) (*DeleteDatasetOperation, error)

DeleteDataset deletes a dataset.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.DeleteDatasetRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#DeleteDatasetRequest.
	}
	op, err := c.DeleteDataset(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*AMLClient) DeleteDatasetOperation 

func (c *AMLClient) DeleteDatasetOperation(name string) *DeleteDatasetOperation

DeleteDatasetOperation returns a new DeleteDatasetOperation from a given name. The name must be that of a previously created DeleteDatasetOperation, possibly from a different process.

func (*AMLClient) DeleteEngineConfig 

func (c *AMLClient) DeleteEngineConfig(ctx context.Context, req *financialservicespb.DeleteEngineConfigRequest, opts ...gax.CallOption) (*DeleteEngineConfigOperation, error)

DeleteEngineConfig deletes an engine config.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.DeleteEngineConfigRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#DeleteEngineConfigRequest.
	}
	op, err := c.DeleteEngineConfig(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*AMLClient) DeleteEngineConfigOperation 

func (c *AMLClient) DeleteEngineConfigOperation(name string) *DeleteEngineConfigOperation

DeleteEngineConfigOperation returns a new DeleteEngineConfigOperation from a given name. The name must be that of a previously created DeleteEngineConfigOperation, possibly from a different process.

func (*AMLClient) DeleteInstance 

func (c *AMLClient) DeleteInstance(ctx context.Context, req *financialservicespb.DeleteInstanceRequest, opts ...gax.CallOption) (*DeleteInstanceOperation, error)

DeleteInstance deletes an instance.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.DeleteInstanceRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#DeleteInstanceRequest.
	}
	op, err := c.DeleteInstance(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*AMLClient) DeleteInstanceOperation 

func (c *AMLClient) DeleteInstanceOperation(name string) *DeleteInstanceOperation

DeleteInstanceOperation returns a new DeleteInstanceOperation from a given name. The name must be that of a previously created DeleteInstanceOperation, possibly from a different process.

func (*AMLClient) DeleteModel 

func (c *AMLClient) DeleteModel(ctx context.Context, req *financialservicespb.DeleteModelRequest, opts ...gax.CallOption) (*DeleteModelOperation, error)

DeleteModel deletes a model.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.DeleteModelRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#DeleteModelRequest.
	}
	op, err := c.DeleteModel(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*AMLClient) DeleteModelOperation 

func (c *AMLClient) DeleteModelOperation(name string) *DeleteModelOperation

DeleteModelOperation returns a new DeleteModelOperation from a given name. The name must be that of a previously created DeleteModelOperation, possibly from a different process.

func (*AMLClient) DeleteOperation 

func (c *AMLClient) DeleteOperation(ctx context.Context, req *longrunningpb.DeleteOperationRequest, opts ...gax.CallOption) error

DeleteOperation is a utility method from google.longrunning.Operations.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.DeleteOperationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#DeleteOperationRequest.
	}
	err = c.DeleteOperation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*AMLClient) DeletePredictionResult 

func (c *AMLClient) DeletePredictionResult(ctx context.Context, req *financialservicespb.DeletePredictionResultRequest, opts ...gax.CallOption) (*DeletePredictionResultOperation, error)

DeletePredictionResult deletes a PredictionResult.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.DeletePredictionResultRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#DeletePredictionResultRequest.
	}
	op, err := c.DeletePredictionResult(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

func (*AMLClient) DeletePredictionResultOperation 

func (c *AMLClient) DeletePredictionResultOperation(name string) *DeletePredictionResultOperation

DeletePredictionResultOperation returns a new DeletePredictionResultOperation from a given name. The name must be that of a previously created DeletePredictionResultOperation, possibly from a different process.

func (*AMLClient) ExportBacktestResultMetadata 

func (c *AMLClient) ExportBacktestResultMetadata(ctx context.Context, req *financialservicespb.ExportBacktestResultMetadataRequest, opts ...gax.CallOption) (*ExportBacktestResultMetadataOperation, error)

ExportBacktestResultMetadata export governance information for a BacktestResult resource. For information on the exported fields, see AML output data model (at https://cloud.google.com/financial-services/anti-money-laundering/docs/reference/schemas/aml-output-data-model#backtest-results).

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ExportBacktestResultMetadataRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ExportBacktestResultMetadataRequest.
	}
	op, err := c.ExportBacktestResultMetadata(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) ExportBacktestResultMetadataOperation 

func (c *AMLClient) ExportBacktestResultMetadataOperation(name string) *ExportBacktestResultMetadataOperation

ExportBacktestResultMetadataOperation returns a new ExportBacktestResultMetadataOperation from a given name. The name must be that of a previously created ExportBacktestResultMetadataOperation, possibly from a different process.

func (*AMLClient) ExportEngineConfigMetadata 

func (c *AMLClient) ExportEngineConfigMetadata(ctx context.Context, req *financialservicespb.ExportEngineConfigMetadataRequest, opts ...gax.CallOption) (*ExportEngineConfigMetadataOperation, error)

ExportEngineConfigMetadata export governance information for an EngineConfig resource. For information on the exported fields, see AML output data model (at https://cloud.google.com/financial-services/anti-money-laundering/docs/reference/schemas/aml-output-data-model#engine-config).

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ExportEngineConfigMetadataRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ExportEngineConfigMetadataRequest.
	}
	op, err := c.ExportEngineConfigMetadata(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) ExportEngineConfigMetadataOperation 

func (c *AMLClient) ExportEngineConfigMetadataOperation(name string) *ExportEngineConfigMetadataOperation

ExportEngineConfigMetadataOperation returns a new ExportEngineConfigMetadataOperation from a given name. The name must be that of a previously created ExportEngineConfigMetadataOperation, possibly from a different process.

func (*AMLClient) ExportModelMetadata 

func (c *AMLClient) ExportModelMetadata(ctx context.Context, req *financialservicespb.ExportModelMetadataRequest, opts ...gax.CallOption) (*ExportModelMetadataOperation, error)

ExportModelMetadata export governance information for a Model resource. For information on the exported fields, see AML output data model (at https://cloud.google.com/financial-services/anti-money-laundering/docs/reference/schemas/aml-output-data-model#model).

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ExportModelMetadataRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ExportModelMetadataRequest.
	}
	op, err := c.ExportModelMetadata(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) ExportModelMetadataOperation 

func (c *AMLClient) ExportModelMetadataOperation(name string) *ExportModelMetadataOperation

ExportModelMetadataOperation returns a new ExportModelMetadataOperation from a given name. The name must be that of a previously created ExportModelMetadataOperation, possibly from a different process.

func (*AMLClient) ExportPredictionResultMetadata 

func (c *AMLClient) ExportPredictionResultMetadata(ctx context.Context, req *financialservicespb.ExportPredictionResultMetadataRequest, opts ...gax.CallOption) (*ExportPredictionResultMetadataOperation, error)

ExportPredictionResultMetadata export governance information for a PredictionResult resource. For information on the exported fields, see AML output data model (at https://cloud.google.com/financial-services/anti-money-laundering/docs/reference/schemas/aml-output-data-model#prediction-results).

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ExportPredictionResultMetadataRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ExportPredictionResultMetadataRequest.
	}
	op, err := c.ExportPredictionResultMetadata(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) ExportPredictionResultMetadataOperation 

func (c *AMLClient) ExportPredictionResultMetadataOperation(name string) *ExportPredictionResultMetadataOperation

ExportPredictionResultMetadataOperation returns a new ExportPredictionResultMetadataOperation from a given name. The name must be that of a previously created ExportPredictionResultMetadataOperation, possibly from a different process.

func (*AMLClient) ExportRegisteredParties 

func (c *AMLClient) ExportRegisteredParties(ctx context.Context, req *financialservicespb.ExportRegisteredPartiesRequest, opts ...gax.CallOption) (*ExportRegisteredPartiesOperation, error)

ExportRegisteredParties exports the list of registered parties. See Create and manage instances (at https://cloud.google.com/financial-services/anti-money-laundering/docs/create-and-manage-instances#export-registered-parties) for information on the output schema for this method.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ExportRegisteredPartiesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ExportRegisteredPartiesRequest.
	}
	op, err := c.ExportRegisteredParties(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) ExportRegisteredPartiesOperation 

func (c *AMLClient) ExportRegisteredPartiesOperation(name string) *ExportRegisteredPartiesOperation

ExportRegisteredPartiesOperation returns a new ExportRegisteredPartiesOperation from a given name. The name must be that of a previously created ExportRegisteredPartiesOperation, possibly from a different process.

func (*AMLClient) GetBacktestResult 

func (c *AMLClient) GetBacktestResult(ctx context.Context, req *financialservicespb.GetBacktestResultRequest, opts ...gax.CallOption) (*financialservicespb.BacktestResult, error)

GetBacktestResult gets a BacktestResult.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.GetBacktestResultRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#GetBacktestResultRequest.
	}
	resp, err := c.GetBacktestResult(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) GetDataset 

func (c *AMLClient) GetDataset(ctx context.Context, req *financialservicespb.GetDatasetRequest, opts ...gax.CallOption) (*financialservicespb.Dataset, error)

GetDataset gets a dataset.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.GetDatasetRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#GetDatasetRequest.
	}
	resp, err := c.GetDataset(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) GetEngineConfig 

func (c *AMLClient) GetEngineConfig(ctx context.Context, req *financialservicespb.GetEngineConfigRequest, opts ...gax.CallOption) (*financialservicespb.EngineConfig, error)

GetEngineConfig gets an engine config.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.GetEngineConfigRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#GetEngineConfigRequest.
	}
	resp, err := c.GetEngineConfig(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) GetEngineVersion 

func (c *AMLClient) GetEngineVersion(ctx context.Context, req *financialservicespb.GetEngineVersionRequest, opts ...gax.CallOption) (*financialservicespb.EngineVersion, error)

GetEngineVersion gets a single EngineVersion.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.GetEngineVersionRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#GetEngineVersionRequest.
	}
	resp, err := c.GetEngineVersion(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) GetInstance 

func (c *AMLClient) GetInstance(ctx context.Context, req *financialservicespb.GetInstanceRequest, opts ...gax.CallOption) (*financialservicespb.Instance, error)

GetInstance gets an instance.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.GetInstanceRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#GetInstanceRequest.
	}
	resp, err := c.GetInstance(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) GetLocation 

func (c *AMLClient) GetLocation(ctx context.Context, req *locationpb.GetLocationRequest, opts ...gax.CallOption) (*locationpb.Location, error)

GetLocation gets information about a location.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"

	locationpb "google.golang.org/genproto/googleapis/cloud/location"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &locationpb.GetLocationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/location#GetLocationRequest.
	}
	resp, err := c.GetLocation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) GetModel 

func (c *AMLClient) GetModel(ctx context.Context, req *financialservicespb.GetModelRequest, opts ...gax.CallOption) (*financialservicespb.Model, error)

GetModel gets a model.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.GetModelRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#GetModelRequest.
	}
	resp, err := c.GetModel(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) GetOperation 

func (c *AMLClient) GetOperation(ctx context.Context, req *longrunningpb.GetOperationRequest, opts ...gax.CallOption) (*longrunningpb.Operation, error)

GetOperation is a utility method from google.longrunning.Operations.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.GetOperationRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#GetOperationRequest.
	}
	resp, err := c.GetOperation(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) GetPredictionResult 

func (c *AMLClient) GetPredictionResult(ctx context.Context, req *financialservicespb.GetPredictionResultRequest, opts ...gax.CallOption) (*financialservicespb.PredictionResult, error)

GetPredictionResult gets a PredictionResult.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.GetPredictionResultRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#GetPredictionResultRequest.
	}
	resp, err := c.GetPredictionResult(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) ImportRegisteredParties 

func (c *AMLClient) ImportRegisteredParties(ctx context.Context, req *financialservicespb.ImportRegisteredPartiesRequest, opts ...gax.CallOption) (*ImportRegisteredPartiesOperation, error)

ImportRegisteredParties imports the list of registered parties. See Create and manage instances (at https://cloud.google.com/financial-services/anti-money-laundering/docs/create-and-manage-instances#import-registered-parties) for information on the input schema and response for this method.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ImportRegisteredPartiesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ImportRegisteredPartiesRequest.
	}
	op, err := c.ImportRegisteredParties(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) ImportRegisteredPartiesOperation 

func (c *AMLClient) ImportRegisteredPartiesOperation(name string) *ImportRegisteredPartiesOperation

ImportRegisteredPartiesOperation returns a new ImportRegisteredPartiesOperation from a given name. The name must be that of a previously created ImportRegisteredPartiesOperation, possibly from a different process.

func (*AMLClient) ListBacktestResults 

func (c *AMLClient) ListBacktestResults(ctx context.Context, req *financialservicespb.ListBacktestResultsRequest, opts ...gax.CallOption) *BacktestResultIterator

ListBacktestResults list BacktestResults.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListBacktestResultsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListBacktestResultsRequest.
	}
	it := c.ListBacktestResults(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*financialservicespb.ListBacktestResultsResponse)
	}
}
Example (All) 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListBacktestResultsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListBacktestResultsRequest.
	}
	for resp, err := range c.ListBacktestResults(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*AMLClient) ListDatasets 

func (c *AMLClient) ListDatasets(ctx context.Context, req *financialservicespb.ListDatasetsRequest, opts ...gax.CallOption) *DatasetIterator

ListDatasets lists datasets.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListDatasetsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListDatasetsRequest.
	}
	it := c.ListDatasets(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*financialservicespb.ListDatasetsResponse)
	}
}
Example (All) 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListDatasetsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListDatasetsRequest.
	}
	for resp, err := range c.ListDatasets(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*AMLClient) ListEngineConfigs 

func (c *AMLClient) ListEngineConfigs(ctx context.Context, req *financialservicespb.ListEngineConfigsRequest, opts ...gax.CallOption) *EngineConfigIterator

ListEngineConfigs lists engine configs.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListEngineConfigsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListEngineConfigsRequest.
	}
	it := c.ListEngineConfigs(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*financialservicespb.ListEngineConfigsResponse)
	}
}
Example (All) 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListEngineConfigsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListEngineConfigsRequest.
	}
	for resp, err := range c.ListEngineConfigs(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*AMLClient) ListEngineVersions 

func (c *AMLClient) ListEngineVersions(ctx context.Context, req *financialservicespb.ListEngineVersionsRequest, opts ...gax.CallOption) *EngineVersionIterator

ListEngineVersions lists EngineVersions for given location.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListEngineVersionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListEngineVersionsRequest.
	}
	it := c.ListEngineVersions(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*financialservicespb.ListEngineVersionsResponse)
	}
}
Example (All) 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListEngineVersionsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListEngineVersionsRequest.
	}
	for resp, err := range c.ListEngineVersions(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*AMLClient) ListInstances 

func (c *AMLClient) ListInstances(ctx context.Context, req *financialservicespb.ListInstancesRequest, opts ...gax.CallOption) *InstanceIterator

ListInstances lists instances.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListInstancesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListInstancesRequest.
	}
	it := c.ListInstances(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*financialservicespb.ListInstancesResponse)
	}
}
Example (All) 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListInstancesRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListInstancesRequest.
	}
	for resp, err := range c.ListInstances(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*AMLClient) ListLocations 

func (c *AMLClient) ListLocations(ctx context.Context, req *locationpb.ListLocationsRequest, opts ...gax.CallOption) *LocationIterator

ListLocations lists information about the supported locations for this service.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	"google.golang.org/api/iterator"

	locationpb "google.golang.org/genproto/googleapis/cloud/location"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &locationpb.ListLocationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/location#ListLocationsRequest.
	}
	it := c.ListLocations(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*locationpb.ListLocationsResponse)
	}
}
Example (All) 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"

	locationpb "google.golang.org/genproto/googleapis/cloud/location"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &locationpb.ListLocationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/location#ListLocationsRequest.
	}
	for resp, err := range c.ListLocations(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*AMLClient) ListModels 

func (c *AMLClient) ListModels(ctx context.Context, req *financialservicespb.ListModelsRequest, opts ...gax.CallOption) *ModelIterator

ListModels lists models.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListModelsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListModelsRequest.
	}
	it := c.ListModels(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*financialservicespb.ListModelsResponse)
	}
}
Example (All) 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListModelsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListModelsRequest.
	}
	for resp, err := range c.ListModels(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*AMLClient) ListOperations 

func (c *AMLClient) ListOperations(ctx context.Context, req *longrunningpb.ListOperationsRequest, opts ...gax.CallOption) *OperationIterator

ListOperations is a utility method from google.longrunning.Operations.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.ListOperationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#ListOperationsRequest.
	}
	it := c.ListOperations(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*longrunningpb.ListOperationsResponse)
	}
}
Example (All) 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"

	longrunningpb "cloud.google.com/go/longrunning/autogen/longrunningpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &longrunningpb.ListOperationsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/longrunning/autogen/longrunningpb#ListOperationsRequest.
	}
	for resp, err := range c.ListOperations(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*AMLClient) ListPredictionResults 

func (c *AMLClient) ListPredictionResults(ctx context.Context, req *financialservicespb.ListPredictionResultsRequest, opts ...gax.CallOption) *PredictionResultIterator

ListPredictionResults list PredictionResults.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListPredictionResultsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListPredictionResultsRequest.
	}
	it := c.ListPredictionResults(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*financialservicespb.ListPredictionResultsResponse)
	}
}
Example (All) 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.ListPredictionResultsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#ListPredictionResultsRequest.
	}
	for resp, err := range c.ListPredictionResults(ctx, req).All() {
		if err != nil {
			// TODO: Handle error and break/return/continue. Iteration will stop after any error.
		}
		// TODO: Use resp.
		_ = resp
	}
}

func (*AMLClient) UpdateBacktestResult 

func (c *AMLClient) UpdateBacktestResult(ctx context.Context, req *financialservicespb.UpdateBacktestResultRequest, opts ...gax.CallOption) (*UpdateBacktestResultOperation, error)

UpdateBacktestResult updates the parameters of a single BacktestResult.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.UpdateBacktestResultRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#UpdateBacktestResultRequest.
	}
	op, err := c.UpdateBacktestResult(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) UpdateBacktestResultOperation 

func (c *AMLClient) UpdateBacktestResultOperation(name string) *UpdateBacktestResultOperation

UpdateBacktestResultOperation returns a new UpdateBacktestResultOperation from a given name. The name must be that of a previously created UpdateBacktestResultOperation, possibly from a different process.

func (*AMLClient) UpdateDataset 

func (c *AMLClient) UpdateDataset(ctx context.Context, req *financialservicespb.UpdateDatasetRequest, opts ...gax.CallOption) (*UpdateDatasetOperation, error)

UpdateDataset updates the parameters of a single Dataset.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.UpdateDatasetRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#UpdateDatasetRequest.
	}
	op, err := c.UpdateDataset(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) UpdateDatasetOperation 

func (c *AMLClient) UpdateDatasetOperation(name string) *UpdateDatasetOperation

UpdateDatasetOperation returns a new UpdateDatasetOperation from a given name. The name must be that of a previously created UpdateDatasetOperation, possibly from a different process.

func (*AMLClient) UpdateEngineConfig 

func (c *AMLClient) UpdateEngineConfig(ctx context.Context, req *financialservicespb.UpdateEngineConfigRequest, opts ...gax.CallOption) (*UpdateEngineConfigOperation, error)

UpdateEngineConfig updates the parameters of a single EngineConfig.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.UpdateEngineConfigRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#UpdateEngineConfigRequest.
	}
	op, err := c.UpdateEngineConfig(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) UpdateEngineConfigOperation 

func (c *AMLClient) UpdateEngineConfigOperation(name string) *UpdateEngineConfigOperation

UpdateEngineConfigOperation returns a new UpdateEngineConfigOperation from a given name. The name must be that of a previously created UpdateEngineConfigOperation, possibly from a different process.

func (*AMLClient) UpdateInstance 

func (c *AMLClient) UpdateInstance(ctx context.Context, req *financialservicespb.UpdateInstanceRequest, opts ...gax.CallOption) (*UpdateInstanceOperation, error)

UpdateInstance updates the parameters of a single Instance.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.UpdateInstanceRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#UpdateInstanceRequest.
	}
	op, err := c.UpdateInstance(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) UpdateInstanceOperation 

func (c *AMLClient) UpdateInstanceOperation(name string) *UpdateInstanceOperation

UpdateInstanceOperation returns a new UpdateInstanceOperation from a given name. The name must be that of a previously created UpdateInstanceOperation, possibly from a different process.

func (*AMLClient) UpdateModel 

func (c *AMLClient) UpdateModel(ctx context.Context, req *financialservicespb.UpdateModelRequest, opts ...gax.CallOption) (*UpdateModelOperation, error)

UpdateModel updates the parameters of a single Model.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.UpdateModelRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#UpdateModelRequest.
	}
	op, err := c.UpdateModel(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) UpdateModelOperation 

func (c *AMLClient) UpdateModelOperation(name string) *UpdateModelOperation

UpdateModelOperation returns a new UpdateModelOperation from a given name. The name must be that of a previously created UpdateModelOperation, possibly from a different process.

func (*AMLClient) UpdatePredictionResult 

func (c *AMLClient) UpdatePredictionResult(ctx context.Context, req *financialservicespb.UpdatePredictionResultRequest, opts ...gax.CallOption) (*UpdatePredictionResultOperation, error)

UpdatePredictionResult updates the parameters of a single PredictionResult.

Example 
package main

import (
	"context"

	financialservices "cloud.google.com/go/financialservices/apiv1"
	financialservicespb "cloud.google.com/go/financialservices/apiv1/financialservicespb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := financialservices.NewAMLClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &financialservicespb.UpdatePredictionResultRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/financialservices/apiv1/financialservicespb#UpdatePredictionResultRequest.
	}
	op, err := c.UpdatePredictionResult(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

func (*AMLClient) UpdatePredictionResultOperation 

func (c *AMLClient) UpdatePredictionResultOperation(name string) *UpdatePredictionResultOperation

UpdatePredictionResultOperation returns a new UpdatePredictionResultOperation from a given name. The name must be that of a previously created UpdatePredictionResultOperation, possibly from a different process.

type BacktestResultIterator 

type BacktestResultIterator struct {

	// 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 []*financialservicespb.BacktestResult, nextPageToken string, err error)
	// contains filtered or unexported fields
}

BacktestResultIterator manages a stream of *financialservicespb.BacktestResult.

func (*BacktestResultIterator) All 

func (it *BacktestResultIterator) All() iter.Seq2[*financialservicespb.BacktestResult, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*BacktestResultIterator) Next 

func (it *BacktestResultIterator) Next() (*financialservicespb.BacktestResult, error)

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 (*BacktestResultIterator) PageInfo 

func (it *BacktestResultIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the google.golang.org/api/iterator package for details.

type CreateBacktestResultOperation 

type CreateBacktestResultOperation struct {
	// contains filtered or unexported fields
}

CreateBacktestResultOperation manages a long-running operation from CreateBacktestResult.

func (*CreateBacktestResultOperation) Done 

func (op *CreateBacktestResultOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateBacktestResultOperation) Metadata 

func (op *CreateBacktestResultOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*CreateBacktestResultOperation) Name 

func (op *CreateBacktestResultOperation) Name() string

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 (*CreateBacktestResultOperation) Poll 

func (op *CreateBacktestResultOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.BacktestResult, error)

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 (*CreateBacktestResultOperation) Wait 

func (op *CreateBacktestResultOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.BacktestResult, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type CreateDatasetOperation 

type CreateDatasetOperation struct {
	// contains filtered or unexported fields
}

CreateDatasetOperation manages a long-running operation from CreateDataset.

func (*CreateDatasetOperation) Done 

func (op *CreateDatasetOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateDatasetOperation) Metadata 

func (op *CreateDatasetOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*CreateDatasetOperation) Name 

func (op *CreateDatasetOperation) Name() string

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 (*CreateDatasetOperation) Poll 

func (op *CreateDatasetOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Dataset, error)

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 (*CreateDatasetOperation) Wait 

func (op *CreateDatasetOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Dataset, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type CreateEngineConfigOperation 

type CreateEngineConfigOperation struct {
	// contains filtered or unexported fields
}

CreateEngineConfigOperation manages a long-running operation from CreateEngineConfig.

func (*CreateEngineConfigOperation) Done 

func (op *CreateEngineConfigOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateEngineConfigOperation) Metadata 

func (op *CreateEngineConfigOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*CreateEngineConfigOperation) Name 

func (op *CreateEngineConfigOperation) Name() string

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 (*CreateEngineConfigOperation) Poll 

func (op *CreateEngineConfigOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.EngineConfig, error)

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 (*CreateEngineConfigOperation) Wait 

func (op *CreateEngineConfigOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.EngineConfig, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type CreateInstanceOperation 

type CreateInstanceOperation struct {
	// contains filtered or unexported fields
}

CreateInstanceOperation manages a long-running operation from CreateInstance.

func (*CreateInstanceOperation) Done 

func (op *CreateInstanceOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateInstanceOperation) Metadata 

func (op *CreateInstanceOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*CreateInstanceOperation) Name 

func (op *CreateInstanceOperation) Name() string

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 (*CreateInstanceOperation) Poll 

func (op *CreateInstanceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Instance, error)

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 (*CreateInstanceOperation) Wait 

func (op *CreateInstanceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Instance, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type CreateModelOperation 

type CreateModelOperation struct {
	// contains filtered or unexported fields
}

CreateModelOperation manages a long-running operation from CreateModel.

func (*CreateModelOperation) Done 

func (op *CreateModelOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreateModelOperation) Metadata 

func (op *CreateModelOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*CreateModelOperation) Name 

func (op *CreateModelOperation) Name() string

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 (*CreateModelOperation) Poll 

func (op *CreateModelOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Model, error)

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 (*CreateModelOperation) Wait 

func (op *CreateModelOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Model, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type CreatePredictionResultOperation 

type CreatePredictionResultOperation struct {
	// contains filtered or unexported fields
}

CreatePredictionResultOperation manages a long-running operation from CreatePredictionResult.

func (*CreatePredictionResultOperation) Done 

func (op *CreatePredictionResultOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*CreatePredictionResultOperation) Metadata 

func (op *CreatePredictionResultOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*CreatePredictionResultOperation) Name 

func (op *CreatePredictionResultOperation) Name() string

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 (*CreatePredictionResultOperation) Poll 

func (op *CreatePredictionResultOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.PredictionResult, error)

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 (*CreatePredictionResultOperation) Wait 

func (op *CreatePredictionResultOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.PredictionResult, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type DatasetIterator 

type DatasetIterator struct {

	// 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 []*financialservicespb.Dataset, nextPageToken string, err error)
	// contains filtered or unexported fields
}

DatasetIterator manages a stream of *financialservicespb.Dataset.

func (*DatasetIterator) All 

func (it *DatasetIterator) All() iter.Seq2[*financialservicespb.Dataset, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*DatasetIterator) Next 

func (it *DatasetIterator) Next() (*financialservicespb.Dataset, error)

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 (*DatasetIterator) PageInfo 

func (it *DatasetIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the google.golang.org/api/iterator package for details.

type DeleteBacktestResultOperation 

type DeleteBacktestResultOperation struct {
	// contains filtered or unexported fields
}

DeleteBacktestResultOperation manages a long-running operation from DeleteBacktestResult.

func (*DeleteBacktestResultOperation) Done 

func (op *DeleteBacktestResultOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteBacktestResultOperation) Metadata 

func (op *DeleteBacktestResultOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*DeleteBacktestResultOperation) Name 

func (op *DeleteBacktestResultOperation) Name() string

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 (*DeleteBacktestResultOperation) Poll 

func (op *DeleteBacktestResultOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

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 (*DeleteBacktestResultOperation) Wait 

func (op *DeleteBacktestResultOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type DeleteDatasetOperation 

type DeleteDatasetOperation struct {
	// contains filtered or unexported fields
}

DeleteDatasetOperation manages a long-running operation from DeleteDataset.

func (*DeleteDatasetOperation) Done 

func (op *DeleteDatasetOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteDatasetOperation) Metadata 

func (op *DeleteDatasetOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*DeleteDatasetOperation) Name 

func (op *DeleteDatasetOperation) Name() string

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 (*DeleteDatasetOperation) Poll 

func (op *DeleteDatasetOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

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 (*DeleteDatasetOperation) Wait 

func (op *DeleteDatasetOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type DeleteEngineConfigOperation 

type DeleteEngineConfigOperation struct {
	// contains filtered or unexported fields
}

DeleteEngineConfigOperation manages a long-running operation from DeleteEngineConfig.

func (*DeleteEngineConfigOperation) Done 

func (op *DeleteEngineConfigOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteEngineConfigOperation) Metadata 

func (op *DeleteEngineConfigOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*DeleteEngineConfigOperation) Name 

func (op *DeleteEngineConfigOperation) Name() string

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 (*DeleteEngineConfigOperation) Poll 

func (op *DeleteEngineConfigOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

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 (*DeleteEngineConfigOperation) Wait 

func (op *DeleteEngineConfigOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type DeleteInstanceOperation 

type DeleteInstanceOperation struct {
	// contains filtered or unexported fields
}

DeleteInstanceOperation manages a long-running operation from DeleteInstance.

func (*DeleteInstanceOperation) Done 

func (op *DeleteInstanceOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteInstanceOperation) Metadata 

func (op *DeleteInstanceOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*DeleteInstanceOperation) Name 

func (op *DeleteInstanceOperation) Name() string

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 (*DeleteInstanceOperation) Poll 

func (op *DeleteInstanceOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

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 (*DeleteInstanceOperation) Wait 

func (op *DeleteInstanceOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type DeleteModelOperation 

type DeleteModelOperation struct {
	// contains filtered or unexported fields
}

DeleteModelOperation manages a long-running operation from DeleteModel.

func (*DeleteModelOperation) Done 

func (op *DeleteModelOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeleteModelOperation) Metadata 

func (op *DeleteModelOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*DeleteModelOperation) Name 

func (op *DeleteModelOperation) Name() string

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 (*DeleteModelOperation) Poll 

func (op *DeleteModelOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

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 (*DeleteModelOperation) Wait 

func (op *DeleteModelOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type DeletePredictionResultOperation 

type DeletePredictionResultOperation struct {
	// contains filtered or unexported fields
}

DeletePredictionResultOperation manages a long-running operation from DeletePredictionResult.

func (*DeletePredictionResultOperation) Done 

func (op *DeletePredictionResultOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*DeletePredictionResultOperation) Metadata 

func (op *DeletePredictionResultOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*DeletePredictionResultOperation) Name 

func (op *DeletePredictionResultOperation) Name() string

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 (*DeletePredictionResultOperation) Poll 

func (op *DeletePredictionResultOperation) Poll(ctx context.Context, opts ...gax.CallOption) error

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 (*DeletePredictionResultOperation) Wait 

func (op *DeletePredictionResultOperation) Wait(ctx context.Context, opts ...gax.CallOption) error

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type EngineConfigIterator 

type EngineConfigIterator struct {

	// 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 []*financialservicespb.EngineConfig, nextPageToken string, err error)
	// contains filtered or unexported fields
}

EngineConfigIterator manages a stream of *financialservicespb.EngineConfig.

func (*EngineConfigIterator) All 

func (it *EngineConfigIterator) All() iter.Seq2[*financialservicespb.EngineConfig, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*EngineConfigIterator) Next 

func (it *EngineConfigIterator) Next() (*financialservicespb.EngineConfig, error)

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 (*EngineConfigIterator) PageInfo 

func (it *EngineConfigIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the google.golang.org/api/iterator package for details.

type EngineVersionIterator 

type EngineVersionIterator struct {

	// 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 []*financialservicespb.EngineVersion, nextPageToken string, err error)
	// contains filtered or unexported fields
}

EngineVersionIterator manages a stream of *financialservicespb.EngineVersion.

func (*EngineVersionIterator) All 

func (it *EngineVersionIterator) All() iter.Seq2[*financialservicespb.EngineVersion, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*EngineVersionIterator) Next 

func (it *EngineVersionIterator) Next() (*financialservicespb.EngineVersion, error)

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 (*EngineVersionIterator) PageInfo 

func (it *EngineVersionIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the google.golang.org/api/iterator package for details.

type ExportBacktestResultMetadataOperation 

type ExportBacktestResultMetadataOperation struct {
	// contains filtered or unexported fields
}

ExportBacktestResultMetadataOperation manages a long-running operation from ExportBacktestResultMetadata.

func (*ExportBacktestResultMetadataOperation) Done 

func (op *ExportBacktestResultMetadataOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*ExportBacktestResultMetadataOperation) Metadata 

func (op *ExportBacktestResultMetadataOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*ExportBacktestResultMetadataOperation) Name 

func (op *ExportBacktestResultMetadataOperation) Name() string

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 (*ExportBacktestResultMetadataOperation) Poll 

func (op *ExportBacktestResultMetadataOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ExportBacktestResultMetadataResponse, error)

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 (*ExportBacktestResultMetadataOperation) Wait 

func (op *ExportBacktestResultMetadataOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ExportBacktestResultMetadataResponse, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type ExportEngineConfigMetadataOperation 

type ExportEngineConfigMetadataOperation struct {
	// contains filtered or unexported fields
}

ExportEngineConfigMetadataOperation manages a long-running operation from ExportEngineConfigMetadata.

func (*ExportEngineConfigMetadataOperation) Done 

func (op *ExportEngineConfigMetadataOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*ExportEngineConfigMetadataOperation) Metadata 

func (op *ExportEngineConfigMetadataOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*ExportEngineConfigMetadataOperation) Name 

func (op *ExportEngineConfigMetadataOperation) Name() string

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 (*ExportEngineConfigMetadataOperation) Poll 

func (op *ExportEngineConfigMetadataOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ExportEngineConfigMetadataResponse, error)

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 (*ExportEngineConfigMetadataOperation) Wait 

func (op *ExportEngineConfigMetadataOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ExportEngineConfigMetadataResponse, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type ExportModelMetadataOperation 

type ExportModelMetadataOperation struct {
	// contains filtered or unexported fields
}

ExportModelMetadataOperation manages a long-running operation from ExportModelMetadata.

func (*ExportModelMetadataOperation) Done 

func (op *ExportModelMetadataOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*ExportModelMetadataOperation) Metadata 

func (op *ExportModelMetadataOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*ExportModelMetadataOperation) Name 

func (op *ExportModelMetadataOperation) Name() string

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 (*ExportModelMetadataOperation) Poll 

func (op *ExportModelMetadataOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ExportModelMetadataResponse, error)

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 (*ExportModelMetadataOperation) Wait 

func (op *ExportModelMetadataOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ExportModelMetadataResponse, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type ExportPredictionResultMetadataOperation 

type ExportPredictionResultMetadataOperation struct {
	// contains filtered or unexported fields
}

ExportPredictionResultMetadataOperation manages a long-running operation from ExportPredictionResultMetadata.

func (*ExportPredictionResultMetadataOperation) Done 

func (op *ExportPredictionResultMetadataOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*ExportPredictionResultMetadataOperation) Metadata 

func (op *ExportPredictionResultMetadataOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*ExportPredictionResultMetadataOperation) Name 

func (op *ExportPredictionResultMetadataOperation) Name() string

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 (*ExportPredictionResultMetadataOperation) Poll 

func (op *ExportPredictionResultMetadataOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ExportPredictionResultMetadataResponse, error)

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 (*ExportPredictionResultMetadataOperation) Wait 

func (op *ExportPredictionResultMetadataOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ExportPredictionResultMetadataResponse, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type ExportRegisteredPartiesOperation 

type ExportRegisteredPartiesOperation struct {
	// contains filtered or unexported fields
}

ExportRegisteredPartiesOperation manages a long-running operation from ExportRegisteredParties.

func (*ExportRegisteredPartiesOperation) Done 

func (op *ExportRegisteredPartiesOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*ExportRegisteredPartiesOperation) Metadata 

func (op *ExportRegisteredPartiesOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*ExportRegisteredPartiesOperation) Name 

func (op *ExportRegisteredPartiesOperation) Name() string

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 (*ExportRegisteredPartiesOperation) Poll 

func (op *ExportRegisteredPartiesOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ExportRegisteredPartiesResponse, error)

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 (*ExportRegisteredPartiesOperation) Wait 

func (op *ExportRegisteredPartiesOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ExportRegisteredPartiesResponse, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type ImportRegisteredPartiesOperation 

type ImportRegisteredPartiesOperation struct {
	// contains filtered or unexported fields
}

ImportRegisteredPartiesOperation manages a long-running operation from ImportRegisteredParties.

func (*ImportRegisteredPartiesOperation) Done 

func (op *ImportRegisteredPartiesOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*ImportRegisteredPartiesOperation) Metadata 

func (op *ImportRegisteredPartiesOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*ImportRegisteredPartiesOperation) Name 

func (op *ImportRegisteredPartiesOperation) Name() string

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 (*ImportRegisteredPartiesOperation) Poll 

func (op *ImportRegisteredPartiesOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ImportRegisteredPartiesResponse, error)

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 (*ImportRegisteredPartiesOperation) Wait 

func (op *ImportRegisteredPartiesOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.ImportRegisteredPartiesResponse, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type InstanceIterator 

type InstanceIterator struct {

	// 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 []*financialservicespb.Instance, nextPageToken string, err error)
	// contains filtered or unexported fields
}

InstanceIterator manages a stream of *financialservicespb.Instance.

func (*InstanceIterator) All 

func (it *InstanceIterator) All() iter.Seq2[*financialservicespb.Instance, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*InstanceIterator) Next 

func (it *InstanceIterator) Next() (*financialservicespb.Instance, error)

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 (*InstanceIterator) PageInfo 

func (it *InstanceIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the google.golang.org/api/iterator package for details.

type LocationIterator 

type LocationIterator struct {

	// 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)
	// contains filtered or unexported fields
}

LocationIterator manages a stream of *locationpb.Location.

func (*LocationIterator) All 

func (it *LocationIterator) All() iter.Seq2[*locationpb.Location, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*LocationIterator) Next 

func (it *LocationIterator) Next() (*locationpb.Location, error)

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 (*LocationIterator) PageInfo 

func (it *LocationIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the google.golang.org/api/iterator package for details.

type ModelIterator 

type ModelIterator struct {

	// 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 []*financialservicespb.Model, nextPageToken string, err error)
	// contains filtered or unexported fields
}

ModelIterator manages a stream of *financialservicespb.Model.

func (*ModelIterator) All 

func (it *ModelIterator) All() iter.Seq2[*financialservicespb.Model, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*ModelIterator) Next 

func (it *ModelIterator) Next() (*financialservicespb.Model, error)

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 (*ModelIterator) PageInfo 

func (it *ModelIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the google.golang.org/api/iterator package for details.

type OperationIterator 

type OperationIterator struct {

	// 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)
	// contains filtered or unexported fields
}

OperationIterator manages a stream of *longrunningpb.Operation.

func (*OperationIterator) All 

func (it *OperationIterator) All() iter.Seq2[*longrunningpb.Operation, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*OperationIterator) Next 

func (it *OperationIterator) Next() (*longrunningpb.Operation, error)

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 (*OperationIterator) PageInfo 

func (it *OperationIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the google.golang.org/api/iterator package for details.

type PredictionResultIterator 

type PredictionResultIterator struct {

	// 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 []*financialservicespb.PredictionResult, nextPageToken string, err error)
	// contains filtered or unexported fields
}

PredictionResultIterator manages a stream of *financialservicespb.PredictionResult.

func (*PredictionResultIterator) All 

func (it *PredictionResultIterator) All() iter.Seq2[*financialservicespb.PredictionResult, error]

All returns an iterator. If an error is returned by the iterator, the iterator will stop after that iteration.

func (*PredictionResultIterator) Next 

func (it *PredictionResultIterator) Next() (*financialservicespb.PredictionResult, error)

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 (*PredictionResultIterator) PageInfo 

func (it *PredictionResultIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the google.golang.org/api/iterator package for details.

type UpdateBacktestResultOperation 

type UpdateBacktestResultOperation struct {
	// contains filtered or unexported fields
}

UpdateBacktestResultOperation manages a long-running operation from UpdateBacktestResult.

func (*UpdateBacktestResultOperation) Done 

func (op *UpdateBacktestResultOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateBacktestResultOperation) Metadata 

func (op *UpdateBacktestResultOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*UpdateBacktestResultOperation) Name 

func (op *UpdateBacktestResultOperation) Name() string

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 (*UpdateBacktestResultOperation) Poll 

func (op *UpdateBacktestResultOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.BacktestResult, error)

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 (*UpdateBacktestResultOperation) Wait 

func (op *UpdateBacktestResultOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.BacktestResult, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type UpdateDatasetOperation 

type UpdateDatasetOperation struct {
	// contains filtered or unexported fields
}

UpdateDatasetOperation manages a long-running operation from UpdateDataset.

func (*UpdateDatasetOperation) Done 

func (op *UpdateDatasetOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateDatasetOperation) Metadata 

func (op *UpdateDatasetOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*UpdateDatasetOperation) Name 

func (op *UpdateDatasetOperation) Name() string

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 (*UpdateDatasetOperation) Poll 

func (op *UpdateDatasetOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Dataset, error)

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 (*UpdateDatasetOperation) Wait 

func (op *UpdateDatasetOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Dataset, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type UpdateEngineConfigOperation 

type UpdateEngineConfigOperation struct {
	// contains filtered or unexported fields
}

UpdateEngineConfigOperation manages a long-running operation from UpdateEngineConfig.

func (*UpdateEngineConfigOperation) Done 

func (op *UpdateEngineConfigOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateEngineConfigOperation) Metadata 

func (op *UpdateEngineConfigOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*UpdateEngineConfigOperation) Name 

func (op *UpdateEngineConfigOperation) Name() string

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 (*UpdateEngineConfigOperation) Poll 

func (op *UpdateEngineConfigOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.EngineConfig, error)

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 (*UpdateEngineConfigOperation) Wait 

func (op *UpdateEngineConfigOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.EngineConfig, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type UpdateInstanceOperation 

type UpdateInstanceOperation struct {
	// contains filtered or unexported fields
}

UpdateInstanceOperation manages a long-running operation from UpdateInstance.

func (*UpdateInstanceOperation) Done 

func (op *UpdateInstanceOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateInstanceOperation) Metadata 

func (op *UpdateInstanceOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*UpdateInstanceOperation) Name 

func (op *UpdateInstanceOperation) Name() string

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 (*UpdateInstanceOperation) Poll 

func (op *UpdateInstanceOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Instance, error)

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 (*UpdateInstanceOperation) Wait 

func (op *UpdateInstanceOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Instance, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type UpdateModelOperation 

type UpdateModelOperation struct {
	// contains filtered or unexported fields
}

UpdateModelOperation manages a long-running operation from UpdateModel.

func (*UpdateModelOperation) Done 

func (op *UpdateModelOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdateModelOperation) Metadata 

func (op *UpdateModelOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*UpdateModelOperation) Name 

func (op *UpdateModelOperation) Name() string

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 (*UpdateModelOperation) Poll 

func (op *UpdateModelOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Model, error)

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 (*UpdateModelOperation) Wait 

func (op *UpdateModelOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.Model, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

type UpdatePredictionResultOperation 

type UpdatePredictionResultOperation struct {
	// contains filtered or unexported fields
}

UpdatePredictionResultOperation manages a long-running operation from UpdatePredictionResult.

func (*UpdatePredictionResultOperation) Done 

func (op *UpdatePredictionResultOperation) Done() bool

Done reports whether the long-running operation has completed.

func (*UpdatePredictionResultOperation) Metadata 

func (op *UpdatePredictionResultOperation) Metadata() (*financialservicespb.OperationMetadata, error)

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 (*UpdatePredictionResultOperation) Name 

func (op *UpdatePredictionResultOperation) Name() string

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 (*UpdatePredictionResultOperation) Poll 

func (op *UpdatePredictionResultOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.PredictionResult, error)

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 (*UpdatePredictionResultOperation) Wait 

func (op *UpdatePredictionResultOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*financialservicespb.PredictionResult, error)

Wait blocks until the long-running operation is completed, returning the response and any errors encountered.

See documentation of Poll for error-handling information.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.