Financial Services API v1 - Package cloud.google.com/go/financialservices/apiv1 (v0.1.3)

Version latest

• 0.1.3 (latest)
• 0.1.2

Beta

This library is covered by the Pre-GA Offerings Terms of the Terms of Service. Pre-GA libraries might have limited support, and changes to pre-GA libraries might not be compatible with other pre-GA versions. For more information, see the launch stage descriptions.

Note: To get more information about this package, such as access to older versions, view this package on pkg.go.dev.

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

NOTE: This package is in beta. It is not stable, and may be subject to changes.

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:

• Authentication and Authorization
• Timeouts and Cancellation
• Testing against Client Libraries
• Debugging Client Libraries
• Inspecting errors

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.

Functions

func DefaultAuthScopes

func DefaultAuthScopes() []string

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

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.

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.

Examples

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)
	}
}

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.

Examples

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)
	}
}

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.

Examples

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)
	}
}

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.

Examples

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)
	}
}

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.

Examples

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)
	}
}

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.

Examples

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)
	}
}

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.

Examples

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)
	}
}

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.

Examples

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)
	}
}

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.

Examples

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)
	}
}

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.