vendor: update all dependencies

vendor/cloud.google.com/go/dialogflow/apiv2/agents_client.go

@@ -0,0 +1,599 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow
+
+import (
+	"math"
+	"time"
+
+	"cloud.google.com/go/internal/version"
+	"cloud.google.com/go/longrunning"
+	lroauto "cloud.google.com/go/longrunning/autogen"
+	structpbpb "github.com/golang/protobuf/ptypes/struct"
+	gax "github.com/googleapis/gax-go"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+	longrunningpb "google.golang.org/genproto/googleapis/longrunning"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+)
+
+// AgentsCallOptions contains the retry settings for each method of AgentsClient.
+type AgentsCallOptions struct {
+	GetAgent     []gax.CallOption
+	SearchAgents []gax.CallOption
+	TrainAgent   []gax.CallOption
+	ExportAgent  []gax.CallOption
+	ImportAgent  []gax.CallOption
+	RestoreAgent []gax.CallOption
+}
+
+func defaultAgentsClientOptions() []option.ClientOption {
+	return []option.ClientOption{
+		option.WithEndpoint("dialogflow.googleapis.com:443"),
+		option.WithScopes(DefaultAuthScopes()...),
+	}
+}
+
+func defaultAgentsCallOptions() *AgentsCallOptions {
+	retry := map[[2]string][]gax.CallOption{
+		{"default", "idempotent"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.DeadlineExceeded,
+					codes.Unavailable,
+				}, gax.Backoff{
+					Initial:    100 * time.Millisecond,
+					Max:        60000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+	}
+	return &AgentsCallOptions{
+		GetAgent:     retry[[2]string{"default", "idempotent"}],
+		SearchAgents: retry[[2]string{"default", "idempotent"}],
+		TrainAgent:   retry[[2]string{"default", "idempotent"}],
+		ExportAgent:  retry[[2]string{"default", "idempotent"}],
+		ImportAgent:  retry[[2]string{"default", "non_idempotent"}],
+		RestoreAgent: retry[[2]string{"default", "idempotent"}],
+	}
+}
+
+// AgentsClient is a client for interacting with Dialogflow API.
+type AgentsClient struct {
+	// The connection to the service.
+	conn *grpc.ClientConn
+
+	// The gRPC API client.
+	agentsClient dialogflowpb.AgentsClient
+
+	// LROClient is used internally to handle longrunning operations.
+	// It is exposed so that its CallOptions can be modified if required.
+	// Users should not Close this client.
+	LROClient *lroauto.OperationsClient
+
+	// The call options for this service.
+	CallOptions *AgentsCallOptions
+
+	// The x-goog-* metadata to be sent with each request.
+	xGoogMetadata metadata.MD
+}
+
+// NewAgentsClient creates a new agents client.
+//
+// Agents are best described as Natural Language Understanding (NLU) modules
+// that transform user requests into actionable data. You can include agents
+// in your app, product, or service to determine user intent and respond to the
+// user in a natural way.
+//
+// After you create an agent, you can add [Intents][google.cloud.dialogflow.v2.Intents], [Contexts][google.cloud.dialogflow.v2.Contexts],
+// [Entity Types][google.cloud.dialogflow.v2.EntityTypes], [Webhooks][google.cloud.dialogflow.v2.WebhookRequest], and so on to
+// manage the flow of a conversation and match user input to predefined intents
+// and actions.
+//
+// You can create an agent using both Dialogflow Standard Edition and
+// Dialogflow Enterprise Edition. For details, see
+// Dialogflow Editions (at /dialogflow-enterprise/docs/editions).
+//
+// You can save your agent for backup or versioning by exporting the agent by
+// using the [ExportAgent][google.cloud.dialogflow.v2.Agents.ExportAgent] method. You can import a saved
+// agent by using the [ImportAgent][google.cloud.dialogflow.v2.Agents.ImportAgent] method.
+//
+// Dialogflow provides several
+// prebuilt agents (at https://dialogflow.com/docs/prebuilt-agents) for common
+// conversation scenarios such as determining a date and time, converting
+// currency, and so on.
+//
+// For more information about agents, see the
+// Dialogflow documentation (at https://dialogflow.com/docs/agents).
+func NewAgentsClient(ctx context.Context, opts ...option.ClientOption) (*AgentsClient, error) {
+	conn, err := transport.DialGRPC(ctx, append(defaultAgentsClientOptions(), opts...)...)
+	if err != nil {
+		return nil, err
+	}
+	c := &AgentsClient{
+		conn:        conn,
+		CallOptions: defaultAgentsCallOptions(),
+
+		agentsClient: dialogflowpb.NewAgentsClient(conn),
+	}
+	c.setGoogleClientInfo()
+
+	c.LROClient, err = lroauto.NewOperationsClient(ctx, option.WithGRPCConn(conn))
+	if err != nil {
+		// This error "should not happen", since we are just reusing old connection
+		// and never actually need to dial.
+		// If this does happen, we could leak conn. However, we cannot close conn:
+		// If the user invoked the function with option.WithGRPCConn,
+		// we would close a connection that's still in use.
+		// TODO(pongad): investigate error conditions.
+		return nil, err
+	}
+	return c, nil
+}
+
+// Connection returns the client's connection to the API service.
+func (c *AgentsClient) Connection() *grpc.ClientConn {
+	return c.conn
+}
+
+// Close closes the connection to the API service. The user should invoke this when
+// the client is no longer required.
+func (c *AgentsClient) Close() error {
+	return c.conn.Close()
+}
+
+// setGoogleClientInfo sets the name and version of the application in
+// the `x-goog-api-client` header passed on each request. Intended for
+// use by Google-written clients.
+func (c *AgentsClient) setGoogleClientInfo(keyval ...string) {
+	kv := append([]string{"gl-go", version.Go()}, keyval...)
+	kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version)
+	c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...))
+}
+
+// GetAgent retrieves the specified agent.
+func (c *AgentsClient) GetAgent(ctx context.Context, req *dialogflowpb.GetAgentRequest, opts ...gax.CallOption) (*dialogflowpb.Agent, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.GetAgent[0:len(c.CallOptions.GetAgent):len(c.CallOptions.GetAgent)], opts...)
+	var resp *dialogflowpb.Agent
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.agentsClient.GetAgent(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// SearchAgents returns the list of agents.
+//
+// Since there is at most one conversational agent per project, this method is
+// useful primarily for listing all agents across projects the caller has
+// access to. One can achieve that with a wildcard project collection id "-".
+// Refer to List
+// Sub-Collections (at https://cloud.google.com/apis/design/design_patterns#list_sub-collections).
+func (c *AgentsClient) SearchAgents(ctx context.Context, req *dialogflowpb.SearchAgentsRequest, opts ...gax.CallOption) *AgentIterator {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.SearchAgents[0:len(c.CallOptions.SearchAgents):len(c.CallOptions.SearchAgents)], opts...)
+	it := &AgentIterator{}
+	it.InternalFetch = func(pageSize int, pageToken string) ([]*dialogflowpb.Agent, string, error) {
+		var resp *dialogflowpb.SearchAgentsResponse
+		req.PageToken = pageToken
+		if pageSize > math.MaxInt32 {
+			req.PageSize = math.MaxInt32
+		} else {
+			req.PageSize = int32(pageSize)
+		}
+		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+			var err error
+			resp, err = c.agentsClient.SearchAgents(ctx, req, settings.GRPC...)
+			return err
+		}, opts...)
+		if err != nil {
+			return nil, "", err
+		}
+		return resp.Agents, resp.NextPageToken, nil
+	}
+	fetch := func(pageSize int, pageToken string) (string, error) {
+		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
+		if err != nil {
+			return "", err
+		}
+		it.items = append(it.items, items...)
+		return nextPageToken, nil
+	}
+	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
+	return it
+}
+
+// TrainAgent trains the specified agent.
+//
+// Operation <response: [google.protobuf.Empty][google.protobuf.Empty],
+// metadata: [google.protobuf.Struct][google.protobuf.Struct]>
+func (c *AgentsClient) TrainAgent(ctx context.Context, req *dialogflowpb.TrainAgentRequest, opts ...gax.CallOption) (*TrainAgentOperation, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.TrainAgent[0:len(c.CallOptions.TrainAgent):len(c.CallOptions.TrainAgent)], opts...)
+	var resp *longrunningpb.Operation
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.agentsClient.TrainAgent(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &TrainAgentOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, resp),
+	}, nil
+}
+
+// ExportAgent exports the specified agent to a ZIP file.
+//
+// Operation <response: [ExportAgentResponse][google.cloud.dialogflow.v2.ExportAgentResponse],
+// metadata: [google.protobuf.Struct][google.protobuf.Struct]>
+func (c *AgentsClient) ExportAgent(ctx context.Context, req *dialogflowpb.ExportAgentRequest, opts ...gax.CallOption) (*ExportAgentOperation, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.ExportAgent[0:len(c.CallOptions.ExportAgent):len(c.CallOptions.ExportAgent)], opts...)
+	var resp *longrunningpb.Operation
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.agentsClient.ExportAgent(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &ExportAgentOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, resp),
+	}, nil
+}
+
+// ImportAgent imports the specified agent from a ZIP file.
+//
+// Uploads new intents and entity types without deleting the existing ones.
+// Intents and entity types with the same name are replaced with the new
+// versions from ImportAgentRequest.
+//
+// Operation <response: [google.protobuf.Empty][google.protobuf.Empty],
+// metadata: [google.protobuf.Struct][google.protobuf.Struct]>
+func (c *AgentsClient) ImportAgent(ctx context.Context, req *dialogflowpb.ImportAgentRequest, opts ...gax.CallOption) (*ImportAgentOperation, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.ImportAgent[0:len(c.CallOptions.ImportAgent):len(c.CallOptions.ImportAgent)], opts...)
+	var resp *longrunningpb.Operation
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.agentsClient.ImportAgent(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &ImportAgentOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, resp),
+	}, nil
+}
+
+// RestoreAgent restores the specified agent from a ZIP file.
+//
+// Replaces the current agent version with a new one. All the intents and
+// entity types in the older version are deleted.
+//
+// Operation <response: [google.protobuf.Empty][google.protobuf.Empty],
+// metadata: [google.protobuf.Struct][google.protobuf.Struct]>
+func (c *AgentsClient) RestoreAgent(ctx context.Context, req *dialogflowpb.RestoreAgentRequest, opts ...gax.CallOption) (*RestoreAgentOperation, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.RestoreAgent[0:len(c.CallOptions.RestoreAgent):len(c.CallOptions.RestoreAgent)], opts...)
+	var resp *longrunningpb.Operation
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.agentsClient.RestoreAgent(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &RestoreAgentOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, resp),
+	}, nil
+}
+
+// AgentIterator manages a stream of *dialogflowpb.Agent.
+type AgentIterator struct {
+	items    []*dialogflowpb.Agent
+	pageInfo *iterator.PageInfo
+	nextFunc func() error
+
+	// 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 []*dialogflowpb.Agent, nextPageToken string, err error)
+}
+
+// PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
+func (it *AgentIterator) PageInfo() *iterator.PageInfo {
+	return it.pageInfo
+}
+
+// Next returns the next result. Its second return value is iterator.Done if there are no more
+// results. Once Next returns Done, all subsequent calls will return Done.
+func (it *AgentIterator) Next() (*dialogflowpb.Agent, error) {
+	var item *dialogflowpb.Agent
+	if err := it.nextFunc(); err != nil {
+		return item, err
+	}
+	item = it.items[0]
+	it.items = it.items[1:]
+	return item, nil
+}
+
+func (it *AgentIterator) bufLen() int {
+	return len(it.items)
+}
+
+func (it *AgentIterator) takeBuf() interface{} {
+	b := it.items
+	it.items = nil
+	return b
+}
+
+// ExportAgentOperation manages a long-running operation from ExportAgent.
+type ExportAgentOperation struct {
+	lro *longrunning.Operation
+}
+
+// ExportAgentOperation returns a new ExportAgentOperation from a given name.
+// The name must be that of a previously created ExportAgentOperation, possibly from a different process.
+func (c *AgentsClient) ExportAgentOperation(name string) *ExportAgentOperation {
+	return &ExportAgentOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
+	}
+}
+
+// Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
+//
+// See documentation of Poll for error-handling information.
+func (op *ExportAgentOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*dialogflowpb.ExportAgentResponse, error) {
+	var resp dialogflowpb.ExportAgentResponse
+	if err := op.lro.WaitWithInterval(ctx, &resp, 5000*time.Millisecond, opts...); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+// Poll fetches the latest state of the long-running operation.
+//
+// Poll also fetches the latest metadata, which can be retrieved by Metadata.
+//
+// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
+// the operation has completed with failure, the error is returned and op.Done will return true.
+// If Poll succeeds and the operation has completed successfully,
+// op.Done will return true, and the response of the operation is returned.
+// If Poll succeeds and the operation has not completed, the returned response and error are both nil.
+func (op *ExportAgentOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*dialogflowpb.ExportAgentResponse, error) {
+	var resp dialogflowpb.ExportAgentResponse
+	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
+		return nil, err
+	}
+	if !op.Done() {
+		return nil, nil
+	}
+	return &resp, nil
+}
+
+// Metadata returns metadata associated with the long-running operation.
+// Metadata itself does not contact the server, but Poll does.
+// To get the latest metadata, call this method after a successful call to Poll.
+// If the metadata is not available, the returned metadata and error are both nil.
+func (op *ExportAgentOperation) Metadata() (*structpbpb.Struct, error) {
+	var meta structpbpb.Struct
+	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+	return &meta, nil
+}
+
+// Done reports whether the long-running operation has completed.
+func (op *ExportAgentOperation) Done() bool {
+	return op.lro.Done()
+}
+
+// Name returns the name of the long-running operation.
+// The name is assigned by the server and is unique within the service from which the operation is created.
+func (op *ExportAgentOperation) Name() string {
+	return op.lro.Name()
+}
+
+// ImportAgentOperation manages a long-running operation from ImportAgent.
+type ImportAgentOperation struct {
+	lro *longrunning.Operation
+}
+
+// ImportAgentOperation returns a new ImportAgentOperation from a given name.
+// The name must be that of a previously created ImportAgentOperation, possibly from a different process.
+func (c *AgentsClient) ImportAgentOperation(name string) *ImportAgentOperation {
+	return &ImportAgentOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
+	}
+}
+
+// Wait blocks until the long-running operation is completed, returning any error encountered.
+//
+// See documentation of Poll for error-handling information.
+func (op *ImportAgentOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.WaitWithInterval(ctx, nil, 5000*time.Millisecond, opts...)
+}
+
+// Poll fetches the latest state of the long-running operation.
+//
+// Poll also fetches the latest metadata, which can be retrieved by Metadata.
+//
+// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
+// the operation has completed with failure, the error is returned and op.Done will return true.
+// If Poll succeeds and the operation has completed successfully, op.Done will return true.
+func (op *ImportAgentOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.Poll(ctx, nil, opts...)
+}
+
+// Metadata returns metadata associated with the long-running operation.
+// Metadata itself does not contact the server, but Poll does.
+// To get the latest metadata, call this method after a successful call to Poll.
+// If the metadata is not available, the returned metadata and error are both nil.
+func (op *ImportAgentOperation) Metadata() (*structpbpb.Struct, error) {
+	var meta structpbpb.Struct
+	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+	return &meta, nil
+}
+
+// Done reports whether the long-running operation has completed.
+func (op *ImportAgentOperation) Done() bool {
+	return op.lro.Done()
+}
+
+// Name returns the name of the long-running operation.
+// The name is assigned by the server and is unique within the service from which the operation is created.
+func (op *ImportAgentOperation) Name() string {
+	return op.lro.Name()
+}
+
+// RestoreAgentOperation manages a long-running operation from RestoreAgent.
+type RestoreAgentOperation struct {
+	lro *longrunning.Operation
+}
+
+// RestoreAgentOperation returns a new RestoreAgentOperation from a given name.
+// The name must be that of a previously created RestoreAgentOperation, possibly from a different process.
+func (c *AgentsClient) RestoreAgentOperation(name string) *RestoreAgentOperation {
+	return &RestoreAgentOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
+	}
+}
+
+// Wait blocks until the long-running operation is completed, returning any error encountered.
+//
+// See documentation of Poll for error-handling information.
+func (op *RestoreAgentOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.WaitWithInterval(ctx, nil, 5000*time.Millisecond, opts...)
+}
+
+// Poll fetches the latest state of the long-running operation.
+//
+// Poll also fetches the latest metadata, which can be retrieved by Metadata.
+//
+// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
+// the operation has completed with failure, the error is returned and op.Done will return true.
+// If Poll succeeds and the operation has completed successfully, op.Done will return true.
+func (op *RestoreAgentOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.Poll(ctx, nil, opts...)
+}
+
+// Metadata returns metadata associated with the long-running operation.
+// Metadata itself does not contact the server, but Poll does.
+// To get the latest metadata, call this method after a successful call to Poll.
+// If the metadata is not available, the returned metadata and error are both nil.
+func (op *RestoreAgentOperation) Metadata() (*structpbpb.Struct, error) {
+	var meta structpbpb.Struct
+	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+	return &meta, nil
+}
+
+// Done reports whether the long-running operation has completed.
+func (op *RestoreAgentOperation) Done() bool {
+	return op.lro.Done()
+}
+
+// Name returns the name of the long-running operation.
+// The name is assigned by the server and is unique within the service from which the operation is created.
+func (op *RestoreAgentOperation) Name() string {
+	return op.lro.Name()
+}
+
+// TrainAgentOperation manages a long-running operation from TrainAgent.
+type TrainAgentOperation struct {
+	lro *longrunning.Operation
+}
+
+// TrainAgentOperation returns a new TrainAgentOperation from a given name.
+// The name must be that of a previously created TrainAgentOperation, possibly from a different process.
+func (c *AgentsClient) TrainAgentOperation(name string) *TrainAgentOperation {
+	return &TrainAgentOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
+	}
+}
+
+// Wait blocks until the long-running operation is completed, returning any error encountered.
+//
+// See documentation of Poll for error-handling information.
+func (op *TrainAgentOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.WaitWithInterval(ctx, nil, 5000*time.Millisecond, opts...)
+}
+
+// Poll fetches the latest state of the long-running operation.
+//
+// Poll also fetches the latest metadata, which can be retrieved by Metadata.
+//
+// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
+// the operation has completed with failure, the error is returned and op.Done will return true.
+// If Poll succeeds and the operation has completed successfully, op.Done will return true.
+func (op *TrainAgentOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.Poll(ctx, nil, opts...)
+}
+
+// Metadata returns metadata associated with the long-running operation.
+// Metadata itself does not contact the server, but Poll does.
+// To get the latest metadata, call this method after a successful call to Poll.
+// If the metadata is not available, the returned metadata and error are both nil.
+func (op *TrainAgentOperation) Metadata() (*structpbpb.Struct, error) {
+	var meta structpbpb.Struct
+	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+	return &meta, nil
+}
+
+// Done reports whether the long-running operation has completed.
+func (op *TrainAgentOperation) Done() bool {
+	return op.lro.Done()
+}
+
+// Name returns the name of the long-running operation.
+// The name is assigned by the server and is unique within the service from which the operation is created.
+func (op *TrainAgentOperation) Name() string {
+	return op.lro.Name()
+}

vendor/cloud.google.com/go/dialogflow/apiv2/agents_client_example_test.go

@@ -0,0 +1,156 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow_test
+
+import (
+	"cloud.google.com/go/dialogflow/apiv2"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+)
+
+func ExampleNewAgentsClient() {
+	ctx := context.Background()
+	c, err := dialogflow.NewAgentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use client.
+	_ = c
+}
+
+func ExampleAgentsClient_GetAgent() {
+	ctx := context.Background()
+	c, err := dialogflow.NewAgentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.GetAgentRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.GetAgent(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleAgentsClient_SearchAgents() {
+	ctx := context.Background()
+	c, err := dialogflow.NewAgentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.SearchAgentsRequest{
+		// TODO: Fill request struct fields.
+	}
+	it := c.SearchAgents(ctx, req)
+	for {
+		resp, err := it.Next()
+		if err == iterator.Done {
+			break
+		}
+		if err != nil {
+			// TODO: Handle error.
+		}
+		// TODO: Use resp.
+		_ = resp
+	}
+}
+
+func ExampleAgentsClient_TrainAgent() {
+	ctx := context.Background()
+	c, err := dialogflow.NewAgentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.TrainAgentRequest{
+		// TODO: Fill request struct fields.
+	}
+	op, err := c.TrainAgent(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	err = op.Wait(ctx)
+	// TODO: Handle error.
+}
+
+func ExampleAgentsClient_ExportAgent() {
+	ctx := context.Background()
+	c, err := dialogflow.NewAgentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.ExportAgentRequest{
+		// TODO: Fill request struct fields.
+	}
+	op, err := c.ExportAgent(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	resp, err := op.Wait(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleAgentsClient_ImportAgent() {
+	ctx := context.Background()
+	c, err := dialogflow.NewAgentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.ImportAgentRequest{
+		// TODO: Fill request struct fields.
+	}
+	op, err := c.ImportAgent(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	err = op.Wait(ctx)
+	// TODO: Handle error.
+}
+
+func ExampleAgentsClient_RestoreAgent() {
+	ctx := context.Background()
+	c, err := dialogflow.NewAgentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.RestoreAgentRequest{
+		// TODO: Fill request struct fields.
+	}
+	op, err := c.RestoreAgent(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	err = op.Wait(ctx)
+	// TODO: Handle error.
+}

vendor/cloud.google.com/go/dialogflow/apiv2/contexts_client.go

@@ -0,0 +1,293 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow
+
+import (
+	"math"
+	"time"
+
+	"cloud.google.com/go/internal/version"
+	gax "github.com/googleapis/gax-go"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+)
+
+// ContextsCallOptions contains the retry settings for each method of ContextsClient.
+type ContextsCallOptions struct {
+	ListContexts      []gax.CallOption
+	GetContext        []gax.CallOption
+	CreateContext     []gax.CallOption
+	UpdateContext     []gax.CallOption
+	DeleteContext     []gax.CallOption
+	DeleteAllContexts []gax.CallOption
+}
+
+func defaultContextsClientOptions() []option.ClientOption {
+	return []option.ClientOption{
+		option.WithEndpoint("dialogflow.googleapis.com:443"),
+		option.WithScopes(DefaultAuthScopes()...),
+	}
+}
+
+func defaultContextsCallOptions() *ContextsCallOptions {
+	retry := map[[2]string][]gax.CallOption{
+		{"default", "idempotent"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.DeadlineExceeded,
+					codes.Unavailable,
+				}, gax.Backoff{
+					Initial:    100 * time.Millisecond,
+					Max:        60000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+	}
+	return &ContextsCallOptions{
+		ListContexts:      retry[[2]string{"default", "idempotent"}],
+		GetContext:        retry[[2]string{"default", "idempotent"}],
+		CreateContext:     retry[[2]string{"default", "non_idempotent"}],
+		UpdateContext:     retry[[2]string{"default", "non_idempotent"}],
+		DeleteContext:     retry[[2]string{"default", "idempotent"}],
+		DeleteAllContexts: retry[[2]string{"default", "idempotent"}],
+	}
+}
+
+// ContextsClient is a client for interacting with Dialogflow API.
+type ContextsClient struct {
+	// The connection to the service.
+	conn *grpc.ClientConn
+
+	// The gRPC API client.
+	contextsClient dialogflowpb.ContextsClient
+
+	// The call options for this service.
+	CallOptions *ContextsCallOptions
+
+	// The x-goog-* metadata to be sent with each request.
+	xGoogMetadata metadata.MD
+}
+
+// NewContextsClient creates a new contexts client.
+//
+// A context represents additional information included with user input or with
+// an intent returned by the Dialogflow API. Contexts are helpful for
+// differentiating user input which may be vague or have a different meaning
+// depending on additional details from your application such as user setting
+// and preferences, previous user input, where the user is in your application,
+// geographic location, and so on.
+//
+// You can include contexts as input parameters of a
+// [DetectIntent][google.cloud.dialogflow.v2.Sessions.DetectIntent] (or
+// [StreamingDetectIntent][google.cloud.dialogflow.v2.Sessions.StreamingDetectIntent]) request,
+// or as output contexts included in the returned intent.
+// Contexts expire when an intent is matched, after the number of DetectIntent
+// requests specified by the lifespan_count parameter, or after 10 minutes
+// if no intents are matched for a DetectIntent request.
+//
+// For more information about contexts, see the
+// Dialogflow documentation (at https://dialogflow.com/docs/contexts).
+func NewContextsClient(ctx context.Context, opts ...option.ClientOption) (*ContextsClient, error) {
+	conn, err := transport.DialGRPC(ctx, append(defaultContextsClientOptions(), opts...)...)
+	if err != nil {
+		return nil, err
+	}
+	c := &ContextsClient{
+		conn:        conn,
+		CallOptions: defaultContextsCallOptions(),
+
+		contextsClient: dialogflowpb.NewContextsClient(conn),
+	}
+	c.setGoogleClientInfo()
+	return c, nil
+}
+
+// Connection returns the client's connection to the API service.
+func (c *ContextsClient) Connection() *grpc.ClientConn {
+	return c.conn
+}
+
+// Close closes the connection to the API service. The user should invoke this when
+// the client is no longer required.
+func (c *ContextsClient) Close() error {
+	return c.conn.Close()
+}
+
+// setGoogleClientInfo sets the name and version of the application in
+// the `x-goog-api-client` header passed on each request. Intended for
+// use by Google-written clients.
+func (c *ContextsClient) setGoogleClientInfo(keyval ...string) {
+	kv := append([]string{"gl-go", version.Go()}, keyval...)
+	kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version)
+	c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...))
+}
+
+// ListContexts returns the list of all contexts in the specified session.
+func (c *ContextsClient) ListContexts(ctx context.Context, req *dialogflowpb.ListContextsRequest, opts ...gax.CallOption) *ContextIterator {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.ListContexts[0:len(c.CallOptions.ListContexts):len(c.CallOptions.ListContexts)], opts...)
+	it := &ContextIterator{}
+	it.InternalFetch = func(pageSize int, pageToken string) ([]*dialogflowpb.Context, string, error) {
+		var resp *dialogflowpb.ListContextsResponse
+		req.PageToken = pageToken
+		if pageSize > math.MaxInt32 {
+			req.PageSize = math.MaxInt32
+		} else {
+			req.PageSize = int32(pageSize)
+		}
+		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+			var err error
+			resp, err = c.contextsClient.ListContexts(ctx, req, settings.GRPC...)
+			return err
+		}, opts...)
+		if err != nil {
+			return nil, "", err
+		}
+		return resp.Contexts, resp.NextPageToken, nil
+	}
+	fetch := func(pageSize int, pageToken string) (string, error) {
+		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
+		if err != nil {
+			return "", err
+		}
+		it.items = append(it.items, items...)
+		return nextPageToken, nil
+	}
+	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
+	return it
+}
+
+// GetContext retrieves the specified context.
+func (c *ContextsClient) GetContext(ctx context.Context, req *dialogflowpb.GetContextRequest, opts ...gax.CallOption) (*dialogflowpb.Context, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.GetContext[0:len(c.CallOptions.GetContext):len(c.CallOptions.GetContext)], opts...)
+	var resp *dialogflowpb.Context
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.contextsClient.GetContext(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// CreateContext creates a context.
+func (c *ContextsClient) CreateContext(ctx context.Context, req *dialogflowpb.CreateContextRequest, opts ...gax.CallOption) (*dialogflowpb.Context, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.CreateContext[0:len(c.CallOptions.CreateContext):len(c.CallOptions.CreateContext)], opts...)
+	var resp *dialogflowpb.Context
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.contextsClient.CreateContext(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// UpdateContext updates the specified context.
+func (c *ContextsClient) UpdateContext(ctx context.Context, req *dialogflowpb.UpdateContextRequest, opts ...gax.CallOption) (*dialogflowpb.Context, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.UpdateContext[0:len(c.CallOptions.UpdateContext):len(c.CallOptions.UpdateContext)], opts...)
+	var resp *dialogflowpb.Context
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.contextsClient.UpdateContext(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// DeleteContext deletes the specified context.
+func (c *ContextsClient) DeleteContext(ctx context.Context, req *dialogflowpb.DeleteContextRequest, opts ...gax.CallOption) error {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.DeleteContext[0:len(c.CallOptions.DeleteContext):len(c.CallOptions.DeleteContext)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.contextsClient.DeleteContext(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// DeleteAllContexts deletes all active contexts in the specified session.
+func (c *ContextsClient) DeleteAllContexts(ctx context.Context, req *dialogflowpb.DeleteAllContextsRequest, opts ...gax.CallOption) error {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.DeleteAllContexts[0:len(c.CallOptions.DeleteAllContexts):len(c.CallOptions.DeleteAllContexts)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.contextsClient.DeleteAllContexts(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// ContextIterator manages a stream of *dialogflowpb.Context.
+type ContextIterator struct {
+	items    []*dialogflowpb.Context
+	pageInfo *iterator.PageInfo
+	nextFunc func() error
+
+	// 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 []*dialogflowpb.Context, nextPageToken string, err error)
+}
+
+// PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
+func (it *ContextIterator) PageInfo() *iterator.PageInfo {
+	return it.pageInfo
+}
+
+// Next returns the next result. Its second return value is iterator.Done if there are no more
+// results. Once Next returns Done, all subsequent calls will return Done.
+func (it *ContextIterator) Next() (*dialogflowpb.Context, error) {
+	var item *dialogflowpb.Context
+	if err := it.nextFunc(); err != nil {
+		return item, err
+	}
+	item = it.items[0]
+	it.items = it.items[1:]
+	return item, nil
+}
+
+func (it *ContextIterator) bufLen() int {
+	return len(it.items)
+}
+
+func (it *ContextIterator) takeBuf() interface{} {
+	b := it.items
+	it.items = nil
+	return b
+}

vendor/cloud.google.com/go/dialogflow/apiv2/contexts_client_example_test.go

@@ -0,0 +1,144 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow_test
+
+import (
+	"cloud.google.com/go/dialogflow/apiv2"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+)
+
+func ExampleNewContextsClient() {
+	ctx := context.Background()
+	c, err := dialogflow.NewContextsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use client.
+	_ = c
+}
+
+func ExampleContextsClient_ListContexts() {
+	ctx := context.Background()
+	c, err := dialogflow.NewContextsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.ListContextsRequest{
+		// TODO: Fill request struct fields.
+	}
+	it := c.ListContexts(ctx, req)
+	for {
+		resp, err := it.Next()
+		if err == iterator.Done {
+			break
+		}
+		if err != nil {
+			// TODO: Handle error.
+		}
+		// TODO: Use resp.
+		_ = resp
+	}
+}
+
+func ExampleContextsClient_GetContext() {
+	ctx := context.Background()
+	c, err := dialogflow.NewContextsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.GetContextRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.GetContext(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleContextsClient_CreateContext() {
+	ctx := context.Background()
+	c, err := dialogflow.NewContextsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.CreateContextRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.CreateContext(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleContextsClient_UpdateContext() {
+	ctx := context.Background()
+	c, err := dialogflow.NewContextsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.UpdateContextRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.UpdateContext(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleContextsClient_DeleteContext() {
+	ctx := context.Background()
+	c, err := dialogflow.NewContextsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.DeleteContextRequest{
+		// TODO: Fill request struct fields.
+	}
+	err = c.DeleteContext(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+}
+
+func ExampleContextsClient_DeleteAllContexts() {
+	ctx := context.Background()
+	c, err := dialogflow.NewContextsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.DeleteAllContextsRequest{
+		// TODO: Fill request struct fields.
+	}
+	err = c.DeleteAllContexts(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+}

vendor/cloud.google.com/go/dialogflow/apiv2/doc.go

@@ -0,0 +1,47 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+// Package dialogflow is an auto-generated package for the
+// Dialogflow API.
+//
+//   NOTE: This package is in alpha. It is not stable, and is likely to change.
+//
+// An end-to-end development suite for conversational interfaces (e.g.,
+// chatbots, voice-powered apps and devices).
+package dialogflow // import "cloud.google.com/go/dialogflow/apiv2"
+
+import (
+	"golang.org/x/net/context"
+	"google.golang.org/grpc/metadata"
+)
+
+func insertMetadata(ctx context.Context, mds ...metadata.MD) context.Context {
+	out, _ := metadata.FromOutgoingContext(ctx)
+	out = out.Copy()
+	for _, md := range mds {
+		for k, v := range md {
+			out[k] = append(out[k], v...)
+		}
+	}
+	return metadata.NewOutgoingContext(ctx, out)
+}
+
+// DefaultAuthScopes reports the default set of authentication scopes to use with this package.
+func DefaultAuthScopes() []string {
+	return []string{
+		"https://www.googleapis.com/auth/cloud-platform",
+	}
+}

vendor/cloud.google.com/go/dialogflow/apiv2/entity_types_client.go

@@ -0,0 +1,718 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow
+
+import (
+	"math"
+	"time"
+
+	"cloud.google.com/go/internal/version"
+	"cloud.google.com/go/longrunning"
+	lroauto "cloud.google.com/go/longrunning/autogen"
+	structpbpb "github.com/golang/protobuf/ptypes/struct"
+	gax "github.com/googleapis/gax-go"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+	longrunningpb "google.golang.org/genproto/googleapis/longrunning"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+)
+
+// EntityTypesCallOptions contains the retry settings for each method of EntityTypesClient.
+type EntityTypesCallOptions struct {
+	ListEntityTypes        []gax.CallOption
+	GetEntityType          []gax.CallOption
+	CreateEntityType       []gax.CallOption
+	UpdateEntityType       []gax.CallOption
+	DeleteEntityType       []gax.CallOption
+	BatchUpdateEntityTypes []gax.CallOption
+	BatchDeleteEntityTypes []gax.CallOption
+	BatchCreateEntities    []gax.CallOption
+	BatchUpdateEntities    []gax.CallOption
+	BatchDeleteEntities    []gax.CallOption
+}
+
+func defaultEntityTypesClientOptions() []option.ClientOption {
+	return []option.ClientOption{
+		option.WithEndpoint("dialogflow.googleapis.com:443"),
+		option.WithScopes(DefaultAuthScopes()...),
+	}
+}
+
+func defaultEntityTypesCallOptions() *EntityTypesCallOptions {
+	retry := map[[2]string][]gax.CallOption{
+		{"default", "idempotent"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.DeadlineExceeded,
+					codes.Unavailable,
+				}, gax.Backoff{
+					Initial:    100 * time.Millisecond,
+					Max:        60000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+	}
+	return &EntityTypesCallOptions{
+		ListEntityTypes:        retry[[2]string{"default", "idempotent"}],
+		GetEntityType:          retry[[2]string{"default", "idempotent"}],
+		CreateEntityType:       retry[[2]string{"default", "non_idempotent"}],
+		UpdateEntityType:       retry[[2]string{"default", "non_idempotent"}],
+		DeleteEntityType:       retry[[2]string{"default", "idempotent"}],
+		BatchUpdateEntityTypes: retry[[2]string{"default", "non_idempotent"}],
+		BatchDeleteEntityTypes: retry[[2]string{"default", "idempotent"}],
+		BatchCreateEntities:    retry[[2]string{"default", "non_idempotent"}],
+		BatchUpdateEntities:    retry[[2]string{"default", "non_idempotent"}],
+		BatchDeleteEntities:    retry[[2]string{"default", "idempotent"}],
+	}
+}
+
+// EntityTypesClient is a client for interacting with Dialogflow API.
+type EntityTypesClient struct {
+	// The connection to the service.
+	conn *grpc.ClientConn
+
+	// The gRPC API client.
+	entityTypesClient dialogflowpb.EntityTypesClient
+
+	// LROClient is used internally to handle longrunning operations.
+	// It is exposed so that its CallOptions can be modified if required.
+	// Users should not Close this client.
+	LROClient *lroauto.OperationsClient
+
+	// The call options for this service.
+	CallOptions *EntityTypesCallOptions
+
+	// The x-goog-* metadata to be sent with each request.
+	xGoogMetadata metadata.MD
+}
+
+// NewEntityTypesClient creates a new entity types client.
+//
+// Entities are extracted from user input and represent parameters that are
+// meaningful to your application. For example, a date range, a proper name
+// such as a geographic location or landmark, and so on. Entities represent
+// actionable data for your application.
+//
+// When you define an entity, you can also include synonyms that all map to
+// that entity. For example, "soft drink", "soda", "pop", and so on.
+//
+// There are three types of entities:
+//
+// *   **System** - entities that are defined by the Dialogflow API for common
+//     data types such as date, time, currency, and so on. A system entity is
+//     represented by the `EntityType` type.
+//
+// *   **Developer** - entities that are defined by you that represent
+//     actionable data that is meaningful to your application. For example,
+//     you could define a `pizza.sauce` entity for red or white pizza sauce,
+//     a `pizza.cheese` entity for the different types of cheese on a pizza,
+//     a `pizza.topping` entity for different toppings, and so on. A developer
+//     entity is represented by the `EntityType` type.
+//
+// *   **User** - entities that are built for an individual user such as
+//     favorites, preferences, playlists, and so on. A user entity is
+//     represented by the [SessionEntityType][google.cloud.dialogflow.v2.SessionEntityType] type.
+//
+// For more information about entity types, see the
+// [Dialogflow documentation](https://dialogflow.com/docs/entities).
+func NewEntityTypesClient(ctx context.Context, opts ...option.ClientOption) (*EntityTypesClient, error) {
+	conn, err := transport.DialGRPC(ctx, append(defaultEntityTypesClientOptions(), opts...)...)
+	if err != nil {
+		return nil, err
+	}
+	c := &EntityTypesClient{
+		conn:        conn,
+		CallOptions: defaultEntityTypesCallOptions(),
+
+		entityTypesClient: dialogflowpb.NewEntityTypesClient(conn),
+	}
+	c.setGoogleClientInfo()
+
+	c.LROClient, err = lroauto.NewOperationsClient(ctx, option.WithGRPCConn(conn))
+	if err != nil {
+		// This error "should not happen", since we are just reusing old connection
+		// and never actually need to dial.
+		// If this does happen, we could leak conn. However, we cannot close conn:
+		// If the user invoked the function with option.WithGRPCConn,
+		// we would close a connection that's still in use.
+		// TODO(pongad): investigate error conditions.
+		return nil, err
+	}
+	return c, nil
+}
+
+// Connection returns the client's connection to the API service.
+func (c *EntityTypesClient) Connection() *grpc.ClientConn {
+	return c.conn
+}
+
+// Close closes the connection to the API service. The user should invoke this when
+// the client is no longer required.
+func (c *EntityTypesClient) Close() error {
+	return c.conn.Close()
+}
+
+// setGoogleClientInfo sets the name and version of the application in
+// the `x-goog-api-client` header passed on each request. Intended for
+// use by Google-written clients.
+func (c *EntityTypesClient) setGoogleClientInfo(keyval ...string) {
+	kv := append([]string{"gl-go", version.Go()}, keyval...)
+	kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version)
+	c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...))
+}
+
+// ListEntityTypes returns the list of all entity types in the specified agent.
+func (c *EntityTypesClient) ListEntityTypes(ctx context.Context, req *dialogflowpb.ListEntityTypesRequest, opts ...gax.CallOption) *EntityTypeIterator {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.ListEntityTypes[0:len(c.CallOptions.ListEntityTypes):len(c.CallOptions.ListEntityTypes)], opts...)
+	it := &EntityTypeIterator{}
+	it.InternalFetch = func(pageSize int, pageToken string) ([]*dialogflowpb.EntityType, string, error) {
+		var resp *dialogflowpb.ListEntityTypesResponse
+		req.PageToken = pageToken
+		if pageSize > math.MaxInt32 {
+			req.PageSize = math.MaxInt32
+		} else {
+			req.PageSize = int32(pageSize)
+		}
+		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+			var err error
+			resp, err = c.entityTypesClient.ListEntityTypes(ctx, req, settings.GRPC...)
+			return err
+		}, opts...)
+		if err != nil {
+			return nil, "", err
+		}
+		return resp.EntityTypes, resp.NextPageToken, nil
+	}
+	fetch := func(pageSize int, pageToken string) (string, error) {
+		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
+		if err != nil {
+			return "", err
+		}
+		it.items = append(it.items, items...)
+		return nextPageToken, nil
+	}
+	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
+	return it
+}
+
+// GetEntityType retrieves the specified entity type.
+func (c *EntityTypesClient) GetEntityType(ctx context.Context, req *dialogflowpb.GetEntityTypeRequest, opts ...gax.CallOption) (*dialogflowpb.EntityType, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.GetEntityType[0:len(c.CallOptions.GetEntityType):len(c.CallOptions.GetEntityType)], opts...)
+	var resp *dialogflowpb.EntityType
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.entityTypesClient.GetEntityType(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// CreateEntityType creates an entity type in the specified agent.
+func (c *EntityTypesClient) CreateEntityType(ctx context.Context, req *dialogflowpb.CreateEntityTypeRequest, opts ...gax.CallOption) (*dialogflowpb.EntityType, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.CreateEntityType[0:len(c.CallOptions.CreateEntityType):len(c.CallOptions.CreateEntityType)], opts...)
+	var resp *dialogflowpb.EntityType
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.entityTypesClient.CreateEntityType(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// UpdateEntityType updates the specified entity type.
+func (c *EntityTypesClient) UpdateEntityType(ctx context.Context, req *dialogflowpb.UpdateEntityTypeRequest, opts ...gax.CallOption) (*dialogflowpb.EntityType, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.UpdateEntityType[0:len(c.CallOptions.UpdateEntityType):len(c.CallOptions.UpdateEntityType)], opts...)
+	var resp *dialogflowpb.EntityType
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.entityTypesClient.UpdateEntityType(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// DeleteEntityType deletes the specified entity type.
+func (c *EntityTypesClient) DeleteEntityType(ctx context.Context, req *dialogflowpb.DeleteEntityTypeRequest, opts ...gax.CallOption) error {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.DeleteEntityType[0:len(c.CallOptions.DeleteEntityType):len(c.CallOptions.DeleteEntityType)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.entityTypesClient.DeleteEntityType(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// BatchUpdateEntityTypes updates/Creates multiple entity types in the specified agent.
+//
+// Operation <response: [BatchUpdateEntityTypesResponse][google.cloud.dialogflow.v2.BatchUpdateEntityTypesResponse],
+// metadata: [google.protobuf.Struct][google.protobuf.Struct]>
+func (c *EntityTypesClient) BatchUpdateEntityTypes(ctx context.Context, req *dialogflowpb.BatchUpdateEntityTypesRequest, opts ...gax.CallOption) (*BatchUpdateEntityTypesOperation, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.BatchUpdateEntityTypes[0:len(c.CallOptions.BatchUpdateEntityTypes):len(c.CallOptions.BatchUpdateEntityTypes)], opts...)
+	var resp *longrunningpb.Operation
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.entityTypesClient.BatchUpdateEntityTypes(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &BatchUpdateEntityTypesOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, resp),
+	}, nil
+}
+
+// BatchDeleteEntityTypes deletes entity types in the specified agent.
+//
+// Operation <response: [google.protobuf.Empty][google.protobuf.Empty],
+// metadata: [google.protobuf.Struct][google.protobuf.Struct]>
+func (c *EntityTypesClient) BatchDeleteEntityTypes(ctx context.Context, req *dialogflowpb.BatchDeleteEntityTypesRequest, opts ...gax.CallOption) (*BatchDeleteEntityTypesOperation, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.BatchDeleteEntityTypes[0:len(c.CallOptions.BatchDeleteEntityTypes):len(c.CallOptions.BatchDeleteEntityTypes)], opts...)
+	var resp *longrunningpb.Operation
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.entityTypesClient.BatchDeleteEntityTypes(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &BatchDeleteEntityTypesOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, resp),
+	}, nil
+}
+
+// BatchCreateEntities creates multiple new entities in the specified entity type (extends the
+// existing collection of entries).
+//
+// Operation <response: [google.protobuf.Empty][google.protobuf.Empty]>
+func (c *EntityTypesClient) BatchCreateEntities(ctx context.Context, req *dialogflowpb.BatchCreateEntitiesRequest, opts ...gax.CallOption) (*BatchCreateEntitiesOperation, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.BatchCreateEntities[0:len(c.CallOptions.BatchCreateEntities):len(c.CallOptions.BatchCreateEntities)], opts...)
+	var resp *longrunningpb.Operation
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.entityTypesClient.BatchCreateEntities(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &BatchCreateEntitiesOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, resp),
+	}, nil
+}
+
+// BatchUpdateEntities updates entities in the specified entity type (replaces the existing
+// collection of entries).
+//
+// Operation <response: [google.protobuf.Empty][google.protobuf.Empty],
+// metadata: [google.protobuf.Struct][google.protobuf.Struct]>
+func (c *EntityTypesClient) BatchUpdateEntities(ctx context.Context, req *dialogflowpb.BatchUpdateEntitiesRequest, opts ...gax.CallOption) (*BatchUpdateEntitiesOperation, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.BatchUpdateEntities[0:len(c.CallOptions.BatchUpdateEntities):len(c.CallOptions.BatchUpdateEntities)], opts...)
+	var resp *longrunningpb.Operation
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.entityTypesClient.BatchUpdateEntities(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &BatchUpdateEntitiesOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, resp),
+	}, nil
+}
+
+// BatchDeleteEntities deletes entities in the specified entity type.
+//
+// Operation <response: [google.protobuf.Empty][google.protobuf.Empty],
+// metadata: [google.protobuf.Struct][google.protobuf.Struct]>
+func (c *EntityTypesClient) BatchDeleteEntities(ctx context.Context, req *dialogflowpb.BatchDeleteEntitiesRequest, opts ...gax.CallOption) (*BatchDeleteEntitiesOperation, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.BatchDeleteEntities[0:len(c.CallOptions.BatchDeleteEntities):len(c.CallOptions.BatchDeleteEntities)], opts...)
+	var resp *longrunningpb.Operation
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.entityTypesClient.BatchDeleteEntities(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &BatchDeleteEntitiesOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, resp),
+	}, nil
+}
+
+// EntityTypeIterator manages a stream of *dialogflowpb.EntityType.
+type EntityTypeIterator struct {
+	items    []*dialogflowpb.EntityType
+	pageInfo *iterator.PageInfo
+	nextFunc func() error
+
+	// 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 []*dialogflowpb.EntityType, nextPageToken string, err error)
+}
+
+// PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
+func (it *EntityTypeIterator) PageInfo() *iterator.PageInfo {
+	return it.pageInfo
+}
+
+// Next returns the next result. Its second return value is iterator.Done if there are no more
+// results. Once Next returns Done, all subsequent calls will return Done.
+func (it *EntityTypeIterator) Next() (*dialogflowpb.EntityType, error) {
+	var item *dialogflowpb.EntityType
+	if err := it.nextFunc(); err != nil {
+		return item, err
+	}
+	item = it.items[0]
+	it.items = it.items[1:]
+	return item, nil
+}
+
+func (it *EntityTypeIterator) bufLen() int {
+	return len(it.items)
+}
+
+func (it *EntityTypeIterator) takeBuf() interface{} {
+	b := it.items
+	it.items = nil
+	return b
+}
+
+// BatchCreateEntitiesOperation manages a long-running operation from BatchCreateEntities.
+type BatchCreateEntitiesOperation struct {
+	lro *longrunning.Operation
+}
+
+// BatchCreateEntitiesOperation returns a new BatchCreateEntitiesOperation from a given name.
+// The name must be that of a previously created BatchCreateEntitiesOperation, possibly from a different process.
+func (c *EntityTypesClient) BatchCreateEntitiesOperation(name string) *BatchCreateEntitiesOperation {
+	return &BatchCreateEntitiesOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
+	}
+}
+
+// Wait blocks until the long-running operation is completed, returning any error encountered.
+//
+// See documentation of Poll for error-handling information.
+func (op *BatchCreateEntitiesOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.WaitWithInterval(ctx, nil, 5000*time.Millisecond, opts...)
+}
+
+// Poll fetches the latest state of the long-running operation.
+//
+// Poll also fetches the latest metadata, which can be retrieved by Metadata.
+//
+// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
+// the operation has completed with failure, the error is returned and op.Done will return true.
+// If Poll succeeds and the operation has completed successfully, op.Done will return true.
+func (op *BatchCreateEntitiesOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.Poll(ctx, nil, opts...)
+}
+
+// Metadata returns metadata associated with the long-running operation.
+// Metadata itself does not contact the server, but Poll does.
+// To get the latest metadata, call this method after a successful call to Poll.
+// If the metadata is not available, the returned metadata and error are both nil.
+func (op *BatchCreateEntitiesOperation) Metadata() (*structpbpb.Struct, error) {
+	var meta structpbpb.Struct
+	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+	return &meta, nil
+}
+
+// Done reports whether the long-running operation has completed.
+func (op *BatchCreateEntitiesOperation) Done() bool {
+	return op.lro.Done()
+}
+
+// Name returns the name of the long-running operation.
+// The name is assigned by the server and is unique within the service from which the operation is created.
+func (op *BatchCreateEntitiesOperation) Name() string {
+	return op.lro.Name()
+}
+
+// BatchDeleteEntitiesOperation manages a long-running operation from BatchDeleteEntities.
+type BatchDeleteEntitiesOperation struct {
+	lro *longrunning.Operation
+}
+
+// BatchDeleteEntitiesOperation returns a new BatchDeleteEntitiesOperation from a given name.
+// The name must be that of a previously created BatchDeleteEntitiesOperation, possibly from a different process.
+func (c *EntityTypesClient) BatchDeleteEntitiesOperation(name string) *BatchDeleteEntitiesOperation {
+	return &BatchDeleteEntitiesOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
+	}
+}
+
+// Wait blocks until the long-running operation is completed, returning any error encountered.
+//
+// See documentation of Poll for error-handling information.
+func (op *BatchDeleteEntitiesOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.WaitWithInterval(ctx, nil, 5000*time.Millisecond, opts...)
+}
+
+// Poll fetches the latest state of the long-running operation.
+//
+// Poll also fetches the latest metadata, which can be retrieved by Metadata.
+//
+// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
+// the operation has completed with failure, the error is returned and op.Done will return true.
+// If Poll succeeds and the operation has completed successfully, op.Done will return true.
+func (op *BatchDeleteEntitiesOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.Poll(ctx, nil, opts...)
+}
+
+// Metadata returns metadata associated with the long-running operation.
+// Metadata itself does not contact the server, but Poll does.
+// To get the latest metadata, call this method after a successful call to Poll.
+// If the metadata is not available, the returned metadata and error are both nil.
+func (op *BatchDeleteEntitiesOperation) Metadata() (*structpbpb.Struct, error) {
+	var meta structpbpb.Struct
+	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+	return &meta, nil
+}
+
+// Done reports whether the long-running operation has completed.
+func (op *BatchDeleteEntitiesOperation) Done() bool {
+	return op.lro.Done()
+}
+
+// Name returns the name of the long-running operation.
+// The name is assigned by the server and is unique within the service from which the operation is created.
+func (op *BatchDeleteEntitiesOperation) Name() string {
+	return op.lro.Name()
+}
+
+// BatchDeleteEntityTypesOperation manages a long-running operation from BatchDeleteEntityTypes.
+type BatchDeleteEntityTypesOperation struct {
+	lro *longrunning.Operation
+}
+
+// BatchDeleteEntityTypesOperation returns a new BatchDeleteEntityTypesOperation from a given name.
+// The name must be that of a previously created BatchDeleteEntityTypesOperation, possibly from a different process.
+func (c *EntityTypesClient) BatchDeleteEntityTypesOperation(name string) *BatchDeleteEntityTypesOperation {
+	return &BatchDeleteEntityTypesOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
+	}
+}
+
+// Wait blocks until the long-running operation is completed, returning any error encountered.
+//
+// See documentation of Poll for error-handling information.
+func (op *BatchDeleteEntityTypesOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.WaitWithInterval(ctx, nil, 5000*time.Millisecond, opts...)
+}
+
+// Poll fetches the latest state of the long-running operation.
+//
+// Poll also fetches the latest metadata, which can be retrieved by Metadata.
+//
+// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
+// the operation has completed with failure, the error is returned and op.Done will return true.
+// If Poll succeeds and the operation has completed successfully, op.Done will return true.
+func (op *BatchDeleteEntityTypesOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.Poll(ctx, nil, opts...)
+}
+
+// Metadata returns metadata associated with the long-running operation.
+// Metadata itself does not contact the server, but Poll does.
+// To get the latest metadata, call this method after a successful call to Poll.
+// If the metadata is not available, the returned metadata and error are both nil.
+func (op *BatchDeleteEntityTypesOperation) Metadata() (*structpbpb.Struct, error) {
+	var meta structpbpb.Struct
+	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+	return &meta, nil
+}
+
+// Done reports whether the long-running operation has completed.
+func (op *BatchDeleteEntityTypesOperation) Done() bool {
+	return op.lro.Done()
+}
+
+// Name returns the name of the long-running operation.
+// The name is assigned by the server and is unique within the service from which the operation is created.
+func (op *BatchDeleteEntityTypesOperation) Name() string {
+	return op.lro.Name()
+}
+
+// BatchUpdateEntitiesOperation manages a long-running operation from BatchUpdateEntities.
+type BatchUpdateEntitiesOperation struct {
+	lro *longrunning.Operation
+}
+
+// BatchUpdateEntitiesOperation returns a new BatchUpdateEntitiesOperation from a given name.
+// The name must be that of a previously created BatchUpdateEntitiesOperation, possibly from a different process.
+func (c *EntityTypesClient) BatchUpdateEntitiesOperation(name string) *BatchUpdateEntitiesOperation {
+	return &BatchUpdateEntitiesOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
+	}
+}
+
+// Wait blocks until the long-running operation is completed, returning any error encountered.
+//
+// See documentation of Poll for error-handling information.
+func (op *BatchUpdateEntitiesOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.WaitWithInterval(ctx, nil, 5000*time.Millisecond, opts...)
+}
+
+// Poll fetches the latest state of the long-running operation.
+//
+// Poll also fetches the latest metadata, which can be retrieved by Metadata.
+//
+// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
+// the operation has completed with failure, the error is returned and op.Done will return true.
+// If Poll succeeds and the operation has completed successfully, op.Done will return true.
+func (op *BatchUpdateEntitiesOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.Poll(ctx, nil, opts...)
+}
+
+// Metadata returns metadata associated with the long-running operation.
+// Metadata itself does not contact the server, but Poll does.
+// To get the latest metadata, call this method after a successful call to Poll.
+// If the metadata is not available, the returned metadata and error are both nil.
+func (op *BatchUpdateEntitiesOperation) Metadata() (*structpbpb.Struct, error) {
+	var meta structpbpb.Struct
+	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+	return &meta, nil
+}
+
+// Done reports whether the long-running operation has completed.
+func (op *BatchUpdateEntitiesOperation) Done() bool {
+	return op.lro.Done()
+}
+
+// Name returns the name of the long-running operation.
+// The name is assigned by the server and is unique within the service from which the operation is created.
+func (op *BatchUpdateEntitiesOperation) Name() string {
+	return op.lro.Name()
+}
+
+// BatchUpdateEntityTypesOperation manages a long-running operation from BatchUpdateEntityTypes.
+type BatchUpdateEntityTypesOperation struct {
+	lro *longrunning.Operation
+}
+
+// BatchUpdateEntityTypesOperation returns a new BatchUpdateEntityTypesOperation from a given name.
+// The name must be that of a previously created BatchUpdateEntityTypesOperation, possibly from a different process.
+func (c *EntityTypesClient) BatchUpdateEntityTypesOperation(name string) *BatchUpdateEntityTypesOperation {
+	return &BatchUpdateEntityTypesOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
+	}
+}
+
+// Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
+//
+// See documentation of Poll for error-handling information.
+func (op *BatchUpdateEntityTypesOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*dialogflowpb.BatchUpdateEntityTypesResponse, error) {
+	var resp dialogflowpb.BatchUpdateEntityTypesResponse
+	if err := op.lro.WaitWithInterval(ctx, &resp, 5000*time.Millisecond, opts...); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+// Poll fetches the latest state of the long-running operation.
+//
+// Poll also fetches the latest metadata, which can be retrieved by Metadata.
+//
+// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
+// the operation has completed with failure, the error is returned and op.Done will return true.
+// If Poll succeeds and the operation has completed successfully,
+// op.Done will return true, and the response of the operation is returned.
+// If Poll succeeds and the operation has not completed, the returned response and error are both nil.
+func (op *BatchUpdateEntityTypesOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*dialogflowpb.BatchUpdateEntityTypesResponse, error) {
+	var resp dialogflowpb.BatchUpdateEntityTypesResponse
+	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
+		return nil, err
+	}
+	if !op.Done() {
+		return nil, nil
+	}
+	return &resp, nil
+}
+
+// Metadata returns metadata associated with the long-running operation.
+// Metadata itself does not contact the server, but Poll does.
+// To get the latest metadata, call this method after a successful call to Poll.
+// If the metadata is not available, the returned metadata and error are both nil.
+func (op *BatchUpdateEntityTypesOperation) Metadata() (*structpbpb.Struct, error) {
+	var meta structpbpb.Struct
+	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+	return &meta, nil
+}
+
+// Done reports whether the long-running operation has completed.
+func (op *BatchUpdateEntityTypesOperation) Done() bool {
+	return op.lro.Done()
+}
+
+// Name returns the name of the long-running operation.
+// The name is assigned by the server and is unique within the service from which the operation is created.
+func (op *BatchUpdateEntityTypesOperation) Name() string {
+	return op.lro.Name()
+}

vendor/cloud.google.com/go/dialogflow/apiv2/entity_types_client_example_test.go

@@ -0,0 +1,227 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow_test
+
+import (
+	"cloud.google.com/go/dialogflow/apiv2"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+)
+
+func ExampleNewEntityTypesClient() {
+	ctx := context.Background()
+	c, err := dialogflow.NewEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use client.
+	_ = c
+}
+
+func ExampleEntityTypesClient_ListEntityTypes() {
+	ctx := context.Background()
+	c, err := dialogflow.NewEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.ListEntityTypesRequest{
+		// TODO: Fill request struct fields.
+	}
+	it := c.ListEntityTypes(ctx, req)
+	for {
+		resp, err := it.Next()
+		if err == iterator.Done {
+			break
+		}
+		if err != nil {
+			// TODO: Handle error.
+		}
+		// TODO: Use resp.
+		_ = resp
+	}
+}
+
+func ExampleEntityTypesClient_GetEntityType() {
+	ctx := context.Background()
+	c, err := dialogflow.NewEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.GetEntityTypeRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.GetEntityType(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleEntityTypesClient_CreateEntityType() {
+	ctx := context.Background()
+	c, err := dialogflow.NewEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.CreateEntityTypeRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.CreateEntityType(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleEntityTypesClient_UpdateEntityType() {
+	ctx := context.Background()
+	c, err := dialogflow.NewEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.UpdateEntityTypeRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.UpdateEntityType(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleEntityTypesClient_DeleteEntityType() {
+	ctx := context.Background()
+	c, err := dialogflow.NewEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.DeleteEntityTypeRequest{
+		// TODO: Fill request struct fields.
+	}
+	err = c.DeleteEntityType(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+}
+
+func ExampleEntityTypesClient_BatchUpdateEntityTypes() {
+	ctx := context.Background()
+	c, err := dialogflow.NewEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.BatchUpdateEntityTypesRequest{
+		// TODO: Fill request struct fields.
+	}
+	op, err := c.BatchUpdateEntityTypes(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	resp, err := op.Wait(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleEntityTypesClient_BatchDeleteEntityTypes() {
+	ctx := context.Background()
+	c, err := dialogflow.NewEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.BatchDeleteEntityTypesRequest{
+		// TODO: Fill request struct fields.
+	}
+	op, err := c.BatchDeleteEntityTypes(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	err = op.Wait(ctx)
+	// TODO: Handle error.
+}
+
+func ExampleEntityTypesClient_BatchCreateEntities() {
+	ctx := context.Background()
+	c, err := dialogflow.NewEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.BatchCreateEntitiesRequest{
+		// TODO: Fill request struct fields.
+	}
+	op, err := c.BatchCreateEntities(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	err = op.Wait(ctx)
+	// TODO: Handle error.
+}
+
+func ExampleEntityTypesClient_BatchUpdateEntities() {
+	ctx := context.Background()
+	c, err := dialogflow.NewEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.BatchUpdateEntitiesRequest{
+		// TODO: Fill request struct fields.
+	}
+	op, err := c.BatchUpdateEntities(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	err = op.Wait(ctx)
+	// TODO: Handle error.
+}
+
+func ExampleEntityTypesClient_BatchDeleteEntities() {
+	ctx := context.Background()
+	c, err := dialogflow.NewEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.BatchDeleteEntitiesRequest{
+		// TODO: Fill request struct fields.
+	}
+	op, err := c.BatchDeleteEntities(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	err = op.Wait(ctx)
+	// TODO: Handle error.
+}

vendor/cloud.google.com/go/dialogflow/apiv2/intents_client.go

@@ -0,0 +1,482 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow
+
+import (
+	"math"
+	"time"
+
+	"cloud.google.com/go/internal/version"
+	"cloud.google.com/go/longrunning"
+	lroauto "cloud.google.com/go/longrunning/autogen"
+	structpbpb "github.com/golang/protobuf/ptypes/struct"
+	gax "github.com/googleapis/gax-go"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+	longrunningpb "google.golang.org/genproto/googleapis/longrunning"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+)
+
+// IntentsCallOptions contains the retry settings for each method of IntentsClient.
+type IntentsCallOptions struct {
+	ListIntents        []gax.CallOption
+	GetIntent          []gax.CallOption
+	CreateIntent       []gax.CallOption
+	UpdateIntent       []gax.CallOption
+	DeleteIntent       []gax.CallOption
+	BatchUpdateIntents []gax.CallOption
+	BatchDeleteIntents []gax.CallOption
+}
+
+func defaultIntentsClientOptions() []option.ClientOption {
+	return []option.ClientOption{
+		option.WithEndpoint("dialogflow.googleapis.com:443"),
+		option.WithScopes(DefaultAuthScopes()...),
+	}
+}
+
+func defaultIntentsCallOptions() *IntentsCallOptions {
+	retry := map[[2]string][]gax.CallOption{
+		{"default", "idempotent"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.DeadlineExceeded,
+					codes.Unavailable,
+				}, gax.Backoff{
+					Initial:    100 * time.Millisecond,
+					Max:        60000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+	}
+	return &IntentsCallOptions{
+		ListIntents:        retry[[2]string{"default", "idempotent"}],
+		GetIntent:          retry[[2]string{"default", "idempotent"}],
+		CreateIntent:       retry[[2]string{"default", "non_idempotent"}],
+		UpdateIntent:       retry[[2]string{"default", "non_idempotent"}],
+		DeleteIntent:       retry[[2]string{"default", "idempotent"}],
+		BatchUpdateIntents: retry[[2]string{"default", "non_idempotent"}],
+		BatchDeleteIntents: retry[[2]string{"default", "idempotent"}],
+	}
+}
+
+// IntentsClient is a client for interacting with Dialogflow API.
+type IntentsClient struct {
+	// The connection to the service.
+	conn *grpc.ClientConn
+
+	// The gRPC API client.
+	intentsClient dialogflowpb.IntentsClient
+
+	// LROClient is used internally to handle longrunning operations.
+	// It is exposed so that its CallOptions can be modified if required.
+	// Users should not Close this client.
+	LROClient *lroauto.OperationsClient
+
+	// The call options for this service.
+	CallOptions *IntentsCallOptions
+
+	// The x-goog-* metadata to be sent with each request.
+	xGoogMetadata metadata.MD
+}
+
+// NewIntentsClient creates a new intents client.
+//
+// An intent represents a mapping between input from a user and an action to
+// be taken by your application. When you pass user input to the
+// [DetectIntent][google.cloud.dialogflow.v2.Sessions.DetectIntent] (or
+// [StreamingDetectIntent][google.cloud.dialogflow.v2.Sessions.StreamingDetectIntent]) method, the
+// Dialogflow API analyzes the input and searches
+// for a matching intent. If no match is found, the Dialogflow API returns a
+// fallback intent (`is_fallback` = true).
+//
+// You can provide additional information for the Dialogflow API to use to
+// match user input to an intent by adding the following to your intent.
+//
+// *   **Contexts** - provide additional context for intent analysis. For
+//     example, if an intent is related to an object in your application that
+//     plays music, you can provide a context to determine when to match the
+//     intent if the user input is “turn it off”.  You can include a context
+//     that matches the intent when there is previous user input of
+//     "play music", and not when there is previous user input of
+//     "turn on the light".
+//
+// *   **Events** - allow for matching an intent by using an event name
+//     instead of user input. Your application can provide an event name and
+//     related parameters to the Dialogflow API to match an intent. For
+//     example, when your application starts, you can send a welcome event
+//     with a user name parameter to the Dialogflow API to match an intent with
+//     a personalized welcome message for the user.
+//
+// *   **Training phrases** - provide examples of user input to train the
+//     Dialogflow API agent to better match intents.
+//
+// For more information about intents, see the
+// [Dialogflow documentation](https://dialogflow.com/docs/intents).
+func NewIntentsClient(ctx context.Context, opts ...option.ClientOption) (*IntentsClient, error) {
+	conn, err := transport.DialGRPC(ctx, append(defaultIntentsClientOptions(), opts...)...)
+	if err != nil {
+		return nil, err
+	}
+	c := &IntentsClient{
+		conn:        conn,
+		CallOptions: defaultIntentsCallOptions(),
+
+		intentsClient: dialogflowpb.NewIntentsClient(conn),
+	}
+	c.setGoogleClientInfo()
+
+	c.LROClient, err = lroauto.NewOperationsClient(ctx, option.WithGRPCConn(conn))
+	if err != nil {
+		// This error "should not happen", since we are just reusing old connection
+		// and never actually need to dial.
+		// If this does happen, we could leak conn. However, we cannot close conn:
+		// If the user invoked the function with option.WithGRPCConn,
+		// we would close a connection that's still in use.
+		// TODO(pongad): investigate error conditions.
+		return nil, err
+	}
+	return c, nil
+}
+
+// Connection returns the client's connection to the API service.
+func (c *IntentsClient) Connection() *grpc.ClientConn {
+	return c.conn
+}
+
+// Close closes the connection to the API service. The user should invoke this when
+// the client is no longer required.
+func (c *IntentsClient) Close() error {
+	return c.conn.Close()
+}
+
+// setGoogleClientInfo sets the name and version of the application in
+// the `x-goog-api-client` header passed on each request. Intended for
+// use by Google-written clients.
+func (c *IntentsClient) setGoogleClientInfo(keyval ...string) {
+	kv := append([]string{"gl-go", version.Go()}, keyval...)
+	kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version)
+	c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...))
+}
+
+// ListIntents returns the list of all intents in the specified agent.
+func (c *IntentsClient) ListIntents(ctx context.Context, req *dialogflowpb.ListIntentsRequest, opts ...gax.CallOption) *IntentIterator {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.ListIntents[0:len(c.CallOptions.ListIntents):len(c.CallOptions.ListIntents)], opts...)
+	it := &IntentIterator{}
+	it.InternalFetch = func(pageSize int, pageToken string) ([]*dialogflowpb.Intent, string, error) {
+		var resp *dialogflowpb.ListIntentsResponse
+		req.PageToken = pageToken
+		if pageSize > math.MaxInt32 {
+			req.PageSize = math.MaxInt32
+		} else {
+			req.PageSize = int32(pageSize)
+		}
+		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+			var err error
+			resp, err = c.intentsClient.ListIntents(ctx, req, settings.GRPC...)
+			return err
+		}, opts...)
+		if err != nil {
+			return nil, "", err
+		}
+		return resp.Intents, resp.NextPageToken, nil
+	}
+	fetch := func(pageSize int, pageToken string) (string, error) {
+		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
+		if err != nil {
+			return "", err
+		}
+		it.items = append(it.items, items...)
+		return nextPageToken, nil
+	}
+	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
+	return it
+}
+
+// GetIntent retrieves the specified intent.
+func (c *IntentsClient) GetIntent(ctx context.Context, req *dialogflowpb.GetIntentRequest, opts ...gax.CallOption) (*dialogflowpb.Intent, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.GetIntent[0:len(c.CallOptions.GetIntent):len(c.CallOptions.GetIntent)], opts...)
+	var resp *dialogflowpb.Intent
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.intentsClient.GetIntent(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// CreateIntent creates an intent in the specified agent.
+func (c *IntentsClient) CreateIntent(ctx context.Context, req *dialogflowpb.CreateIntentRequest, opts ...gax.CallOption) (*dialogflowpb.Intent, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.CreateIntent[0:len(c.CallOptions.CreateIntent):len(c.CallOptions.CreateIntent)], opts...)
+	var resp *dialogflowpb.Intent
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.intentsClient.CreateIntent(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// UpdateIntent updates the specified intent.
+func (c *IntentsClient) UpdateIntent(ctx context.Context, req *dialogflowpb.UpdateIntentRequest, opts ...gax.CallOption) (*dialogflowpb.Intent, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.UpdateIntent[0:len(c.CallOptions.UpdateIntent):len(c.CallOptions.UpdateIntent)], opts...)
+	var resp *dialogflowpb.Intent
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.intentsClient.UpdateIntent(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// DeleteIntent deletes the specified intent.
+func (c *IntentsClient) DeleteIntent(ctx context.Context, req *dialogflowpb.DeleteIntentRequest, opts ...gax.CallOption) error {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.DeleteIntent[0:len(c.CallOptions.DeleteIntent):len(c.CallOptions.DeleteIntent)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.intentsClient.DeleteIntent(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// BatchUpdateIntents updates/Creates multiple intents in the specified agent.
+//
+// Operation <response: [BatchUpdateIntentsResponse][google.cloud.dialogflow.v2.BatchUpdateIntentsResponse]>
+func (c *IntentsClient) BatchUpdateIntents(ctx context.Context, req *dialogflowpb.BatchUpdateIntentsRequest, opts ...gax.CallOption) (*BatchUpdateIntentsOperation, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.BatchUpdateIntents[0:len(c.CallOptions.BatchUpdateIntents):len(c.CallOptions.BatchUpdateIntents)], opts...)
+	var resp *longrunningpb.Operation
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.intentsClient.BatchUpdateIntents(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &BatchUpdateIntentsOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, resp),
+	}, nil
+}
+
+// BatchDeleteIntents deletes intents in the specified agent.
+//
+// Operation <response: [google.protobuf.Empty][google.protobuf.Empty]>
+func (c *IntentsClient) BatchDeleteIntents(ctx context.Context, req *dialogflowpb.BatchDeleteIntentsRequest, opts ...gax.CallOption) (*BatchDeleteIntentsOperation, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.BatchDeleteIntents[0:len(c.CallOptions.BatchDeleteIntents):len(c.CallOptions.BatchDeleteIntents)], opts...)
+	var resp *longrunningpb.Operation
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.intentsClient.BatchDeleteIntents(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &BatchDeleteIntentsOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, resp),
+	}, nil
+}
+
+// IntentIterator manages a stream of *dialogflowpb.Intent.
+type IntentIterator struct {
+	items    []*dialogflowpb.Intent
+	pageInfo *iterator.PageInfo
+	nextFunc func() error
+
+	// 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 []*dialogflowpb.Intent, nextPageToken string, err error)
+}
+
+// PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
+func (it *IntentIterator) PageInfo() *iterator.PageInfo {
+	return it.pageInfo
+}
+
+// Next returns the next result. Its second return value is iterator.Done if there are no more
+// results. Once Next returns Done, all subsequent calls will return Done.
+func (it *IntentIterator) Next() (*dialogflowpb.Intent, error) {
+	var item *dialogflowpb.Intent
+	if err := it.nextFunc(); err != nil {
+		return item, err
+	}
+	item = it.items[0]
+	it.items = it.items[1:]
+	return item, nil
+}
+
+func (it *IntentIterator) bufLen() int {
+	return len(it.items)
+}
+
+func (it *IntentIterator) takeBuf() interface{} {
+	b := it.items
+	it.items = nil
+	return b
+}
+
+// BatchDeleteIntentsOperation manages a long-running operation from BatchDeleteIntents.
+type BatchDeleteIntentsOperation struct {
+	lro *longrunning.Operation
+}
+
+// BatchDeleteIntentsOperation returns a new BatchDeleteIntentsOperation from a given name.
+// The name must be that of a previously created BatchDeleteIntentsOperation, possibly from a different process.
+func (c *IntentsClient) BatchDeleteIntentsOperation(name string) *BatchDeleteIntentsOperation {
+	return &BatchDeleteIntentsOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
+	}
+}
+
+// Wait blocks until the long-running operation is completed, returning any error encountered.
+//
+// See documentation of Poll for error-handling information.
+func (op *BatchDeleteIntentsOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.WaitWithInterval(ctx, nil, 5000*time.Millisecond, opts...)
+}
+
+// Poll fetches the latest state of the long-running operation.
+//
+// Poll also fetches the latest metadata, which can be retrieved by Metadata.
+//
+// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
+// the operation has completed with failure, the error is returned and op.Done will return true.
+// If Poll succeeds and the operation has completed successfully, op.Done will return true.
+func (op *BatchDeleteIntentsOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
+	return op.lro.Poll(ctx, nil, opts...)
+}
+
+// Metadata returns metadata associated with the long-running operation.
+// Metadata itself does not contact the server, but Poll does.
+// To get the latest metadata, call this method after a successful call to Poll.
+// If the metadata is not available, the returned metadata and error are both nil.
+func (op *BatchDeleteIntentsOperation) Metadata() (*structpbpb.Struct, error) {
+	var meta structpbpb.Struct
+	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+	return &meta, nil
+}
+
+// Done reports whether the long-running operation has completed.
+func (op *BatchDeleteIntentsOperation) Done() bool {
+	return op.lro.Done()
+}
+
+// Name returns the name of the long-running operation.
+// The name is assigned by the server and is unique within the service from which the operation is created.
+func (op *BatchDeleteIntentsOperation) Name() string {
+	return op.lro.Name()
+}
+
+// BatchUpdateIntentsOperation manages a long-running operation from BatchUpdateIntents.
+type BatchUpdateIntentsOperation struct {
+	lro *longrunning.Operation
+}
+
+// BatchUpdateIntentsOperation returns a new BatchUpdateIntentsOperation from a given name.
+// The name must be that of a previously created BatchUpdateIntentsOperation, possibly from a different process.
+func (c *IntentsClient) BatchUpdateIntentsOperation(name string) *BatchUpdateIntentsOperation {
+	return &BatchUpdateIntentsOperation{
+		lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
+	}
+}
+
+// Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
+//
+// See documentation of Poll for error-handling information.
+func (op *BatchUpdateIntentsOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*dialogflowpb.BatchUpdateIntentsResponse, error) {
+	var resp dialogflowpb.BatchUpdateIntentsResponse
+	if err := op.lro.WaitWithInterval(ctx, &resp, 5000*time.Millisecond, opts...); err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
+// Poll fetches the latest state of the long-running operation.
+//
+// Poll also fetches the latest metadata, which can be retrieved by Metadata.
+//
+// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
+// the operation has completed with failure, the error is returned and op.Done will return true.
+// If Poll succeeds and the operation has completed successfully,
+// op.Done will return true, and the response of the operation is returned.
+// If Poll succeeds and the operation has not completed, the returned response and error are both nil.
+func (op *BatchUpdateIntentsOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*dialogflowpb.BatchUpdateIntentsResponse, error) {
+	var resp dialogflowpb.BatchUpdateIntentsResponse
+	if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
+		return nil, err
+	}
+	if !op.Done() {
+		return nil, nil
+	}
+	return &resp, nil
+}
+
+// Metadata returns metadata associated with the long-running operation.
+// Metadata itself does not contact the server, but Poll does.
+// To get the latest metadata, call this method after a successful call to Poll.
+// If the metadata is not available, the returned metadata and error are both nil.
+func (op *BatchUpdateIntentsOperation) Metadata() (*structpbpb.Struct, error) {
+	var meta structpbpb.Struct
+	if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+	return &meta, nil
+}
+
+// Done reports whether the long-running operation has completed.
+func (op *BatchUpdateIntentsOperation) Done() bool {
+	return op.lro.Done()
+}
+
+// Name returns the name of the long-running operation.
+// The name is assigned by the server and is unique within the service from which the operation is created.
+func (op *BatchUpdateIntentsOperation) Name() string {
+	return op.lro.Name()
+}

vendor/cloud.google.com/go/dialogflow/apiv2/intents_client_example_test.go

@@ -0,0 +1,170 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow_test
+
+import (
+	"cloud.google.com/go/dialogflow/apiv2"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+)
+
+func ExampleNewIntentsClient() {
+	ctx := context.Background()
+	c, err := dialogflow.NewIntentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use client.
+	_ = c
+}
+
+func ExampleIntentsClient_ListIntents() {
+	ctx := context.Background()
+	c, err := dialogflow.NewIntentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.ListIntentsRequest{
+		// TODO: Fill request struct fields.
+	}
+	it := c.ListIntents(ctx, req)
+	for {
+		resp, err := it.Next()
+		if err == iterator.Done {
+			break
+		}
+		if err != nil {
+			// TODO: Handle error.
+		}
+		// TODO: Use resp.
+		_ = resp
+	}
+}
+
+func ExampleIntentsClient_GetIntent() {
+	ctx := context.Background()
+	c, err := dialogflow.NewIntentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.GetIntentRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.GetIntent(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleIntentsClient_CreateIntent() {
+	ctx := context.Background()
+	c, err := dialogflow.NewIntentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.CreateIntentRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.CreateIntent(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleIntentsClient_UpdateIntent() {
+	ctx := context.Background()
+	c, err := dialogflow.NewIntentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.UpdateIntentRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.UpdateIntent(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleIntentsClient_DeleteIntent() {
+	ctx := context.Background()
+	c, err := dialogflow.NewIntentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.DeleteIntentRequest{
+		// TODO: Fill request struct fields.
+	}
+	err = c.DeleteIntent(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+}
+
+func ExampleIntentsClient_BatchUpdateIntents() {
+	ctx := context.Background()
+	c, err := dialogflow.NewIntentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.BatchUpdateIntentsRequest{
+		// TODO: Fill request struct fields.
+	}
+	op, err := c.BatchUpdateIntents(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	resp, err := op.Wait(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleIntentsClient_BatchDeleteIntents() {
+	ctx := context.Background()
+	c, err := dialogflow.NewIntentsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.BatchDeleteIntentsRequest{
+		// TODO: Fill request struct fields.
+	}
+	op, err := c.BatchDeleteIntents(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	err = op.Wait(ctx)
+	// TODO: Handle error.
+}

vendor/cloud.google.com/go/dialogflow/apiv2/session_entity_types_client.go

@@ -0,0 +1,274 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow
+
+import (
+	"math"
+	"time"
+
+	"cloud.google.com/go/internal/version"
+	gax "github.com/googleapis/gax-go"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+)
+
+// SessionEntityTypesCallOptions contains the retry settings for each method of SessionEntityTypesClient.
+type SessionEntityTypesCallOptions struct {
+	ListSessionEntityTypes  []gax.CallOption
+	GetSessionEntityType    []gax.CallOption
+	CreateSessionEntityType []gax.CallOption
+	UpdateSessionEntityType []gax.CallOption
+	DeleteSessionEntityType []gax.CallOption
+}
+
+func defaultSessionEntityTypesClientOptions() []option.ClientOption {
+	return []option.ClientOption{
+		option.WithEndpoint("dialogflow.googleapis.com:443"),
+		option.WithScopes(DefaultAuthScopes()...),
+	}
+}
+
+func defaultSessionEntityTypesCallOptions() *SessionEntityTypesCallOptions {
+	retry := map[[2]string][]gax.CallOption{
+		{"default", "idempotent"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.DeadlineExceeded,
+					codes.Unavailable,
+				}, gax.Backoff{
+					Initial:    100 * time.Millisecond,
+					Max:        60000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+	}
+	return &SessionEntityTypesCallOptions{
+		ListSessionEntityTypes:  retry[[2]string{"default", "idempotent"}],
+		GetSessionEntityType:    retry[[2]string{"default", "idempotent"}],
+		CreateSessionEntityType: retry[[2]string{"default", "non_idempotent"}],
+		UpdateSessionEntityType: retry[[2]string{"default", "non_idempotent"}],
+		DeleteSessionEntityType: retry[[2]string{"default", "idempotent"}],
+	}
+}
+
+// SessionEntityTypesClient is a client for interacting with Dialogflow API.
+type SessionEntityTypesClient struct {
+	// The connection to the service.
+	conn *grpc.ClientConn
+
+	// The gRPC API client.
+	sessionEntityTypesClient dialogflowpb.SessionEntityTypesClient
+
+	// The call options for this service.
+	CallOptions *SessionEntityTypesCallOptions
+
+	// The x-goog-* metadata to be sent with each request.
+	xGoogMetadata metadata.MD
+}
+
+// NewSessionEntityTypesClient creates a new session entity types client.
+//
+// Entities are extracted from user input and represent parameters that are
+// meaningful to your application. For example, a date range, a proper name
+// such as a geographic location or landmark, and so on. Entities represent
+// actionable data for your application.
+//
+// Session entity types are referred to as **User** entity types and are
+// entities that are built for an individual user such as
+// favorites, preferences, playlists, and so on. You can redefine a session
+// entity type at the session level.
+//
+// For more information about entity types, see the
+// [Dialogflow documentation](https://dialogflow.com/docs/entities).
+func NewSessionEntityTypesClient(ctx context.Context, opts ...option.ClientOption) (*SessionEntityTypesClient, error) {
+	conn, err := transport.DialGRPC(ctx, append(defaultSessionEntityTypesClientOptions(), opts...)...)
+	if err != nil {
+		return nil, err
+	}
+	c := &SessionEntityTypesClient{
+		conn:        conn,
+		CallOptions: defaultSessionEntityTypesCallOptions(),
+
+		sessionEntityTypesClient: dialogflowpb.NewSessionEntityTypesClient(conn),
+	}
+	c.setGoogleClientInfo()
+	return c, nil
+}
+
+// Connection returns the client's connection to the API service.
+func (c *SessionEntityTypesClient) Connection() *grpc.ClientConn {
+	return c.conn
+}
+
+// Close closes the connection to the API service. The user should invoke this when
+// the client is no longer required.
+func (c *SessionEntityTypesClient) Close() error {
+	return c.conn.Close()
+}
+
+// setGoogleClientInfo sets the name and version of the application in
+// the `x-goog-api-client` header passed on each request. Intended for
+// use by Google-written clients.
+func (c *SessionEntityTypesClient) setGoogleClientInfo(keyval ...string) {
+	kv := append([]string{"gl-go", version.Go()}, keyval...)
+	kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version)
+	c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...))
+}
+
+// ListSessionEntityTypes returns the list of all session entity types in the specified session.
+func (c *SessionEntityTypesClient) ListSessionEntityTypes(ctx context.Context, req *dialogflowpb.ListSessionEntityTypesRequest, opts ...gax.CallOption) *SessionEntityTypeIterator {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.ListSessionEntityTypes[0:len(c.CallOptions.ListSessionEntityTypes):len(c.CallOptions.ListSessionEntityTypes)], opts...)
+	it := &SessionEntityTypeIterator{}
+	it.InternalFetch = func(pageSize int, pageToken string) ([]*dialogflowpb.SessionEntityType, string, error) {
+		var resp *dialogflowpb.ListSessionEntityTypesResponse
+		req.PageToken = pageToken
+		if pageSize > math.MaxInt32 {
+			req.PageSize = math.MaxInt32
+		} else {
+			req.PageSize = int32(pageSize)
+		}
+		err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+			var err error
+			resp, err = c.sessionEntityTypesClient.ListSessionEntityTypes(ctx, req, settings.GRPC...)
+			return err
+		}, opts...)
+		if err != nil {
+			return nil, "", err
+		}
+		return resp.SessionEntityTypes, resp.NextPageToken, nil
+	}
+	fetch := func(pageSize int, pageToken string) (string, error) {
+		items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
+		if err != nil {
+			return "", err
+		}
+		it.items = append(it.items, items...)
+		return nextPageToken, nil
+	}
+	it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
+	return it
+}
+
+// GetSessionEntityType retrieves the specified session entity type.
+func (c *SessionEntityTypesClient) GetSessionEntityType(ctx context.Context, req *dialogflowpb.GetSessionEntityTypeRequest, opts ...gax.CallOption) (*dialogflowpb.SessionEntityType, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.GetSessionEntityType[0:len(c.CallOptions.GetSessionEntityType):len(c.CallOptions.GetSessionEntityType)], opts...)
+	var resp *dialogflowpb.SessionEntityType
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.sessionEntityTypesClient.GetSessionEntityType(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// CreateSessionEntityType creates a session entity type.
+func (c *SessionEntityTypesClient) CreateSessionEntityType(ctx context.Context, req *dialogflowpb.CreateSessionEntityTypeRequest, opts ...gax.CallOption) (*dialogflowpb.SessionEntityType, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.CreateSessionEntityType[0:len(c.CallOptions.CreateSessionEntityType):len(c.CallOptions.CreateSessionEntityType)], opts...)
+	var resp *dialogflowpb.SessionEntityType
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.sessionEntityTypesClient.CreateSessionEntityType(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// UpdateSessionEntityType updates the specified session entity type.
+func (c *SessionEntityTypesClient) UpdateSessionEntityType(ctx context.Context, req *dialogflowpb.UpdateSessionEntityTypeRequest, opts ...gax.CallOption) (*dialogflowpb.SessionEntityType, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.UpdateSessionEntityType[0:len(c.CallOptions.UpdateSessionEntityType):len(c.CallOptions.UpdateSessionEntityType)], opts...)
+	var resp *dialogflowpb.SessionEntityType
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.sessionEntityTypesClient.UpdateSessionEntityType(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// DeleteSessionEntityType deletes the specified session entity type.
+func (c *SessionEntityTypesClient) DeleteSessionEntityType(ctx context.Context, req *dialogflowpb.DeleteSessionEntityTypeRequest, opts ...gax.CallOption) error {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.DeleteSessionEntityType[0:len(c.CallOptions.DeleteSessionEntityType):len(c.CallOptions.DeleteSessionEntityType)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.sessionEntityTypesClient.DeleteSessionEntityType(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// SessionEntityTypeIterator manages a stream of *dialogflowpb.SessionEntityType.
+type SessionEntityTypeIterator struct {
+	items    []*dialogflowpb.SessionEntityType
+	pageInfo *iterator.PageInfo
+	nextFunc func() error
+
+	// 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 []*dialogflowpb.SessionEntityType, nextPageToken string, err error)
+}
+
+// PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
+func (it *SessionEntityTypeIterator) PageInfo() *iterator.PageInfo {
+	return it.pageInfo
+}
+
+// Next returns the next result. Its second return value is iterator.Done if there are no more
+// results. Once Next returns Done, all subsequent calls will return Done.
+func (it *SessionEntityTypeIterator) Next() (*dialogflowpb.SessionEntityType, error) {
+	var item *dialogflowpb.SessionEntityType
+	if err := it.nextFunc(); err != nil {
+		return item, err
+	}
+	item = it.items[0]
+	it.items = it.items[1:]
+	return item, nil
+}
+
+func (it *SessionEntityTypeIterator) bufLen() int {
+	return len(it.items)
+}
+
+func (it *SessionEntityTypeIterator) takeBuf() interface{} {
+	b := it.items
+	it.items = nil
+	return b
+}

vendor/cloud.google.com/go/dialogflow/apiv2/session_entity_types_client_example_test.go

@@ -0,0 +1,128 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow_test
+
+import (
+	"cloud.google.com/go/dialogflow/apiv2"
+	"golang.org/x/net/context"
+	"google.golang.org/api/iterator"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+)
+
+func ExampleNewSessionEntityTypesClient() {
+	ctx := context.Background()
+	c, err := dialogflow.NewSessionEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use client.
+	_ = c
+}
+
+func ExampleSessionEntityTypesClient_ListSessionEntityTypes() {
+	ctx := context.Background()
+	c, err := dialogflow.NewSessionEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.ListSessionEntityTypesRequest{
+		// TODO: Fill request struct fields.
+	}
+	it := c.ListSessionEntityTypes(ctx, req)
+	for {
+		resp, err := it.Next()
+		if err == iterator.Done {
+			break
+		}
+		if err != nil {
+			// TODO: Handle error.
+		}
+		// TODO: Use resp.
+		_ = resp
+	}
+}
+
+func ExampleSessionEntityTypesClient_GetSessionEntityType() {
+	ctx := context.Background()
+	c, err := dialogflow.NewSessionEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.GetSessionEntityTypeRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.GetSessionEntityType(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleSessionEntityTypesClient_CreateSessionEntityType() {
+	ctx := context.Background()
+	c, err := dialogflow.NewSessionEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.CreateSessionEntityTypeRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.CreateSessionEntityType(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleSessionEntityTypesClient_UpdateSessionEntityType() {
+	ctx := context.Background()
+	c, err := dialogflow.NewSessionEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.UpdateSessionEntityTypeRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.UpdateSessionEntityType(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleSessionEntityTypesClient_DeleteSessionEntityType() {
+	ctx := context.Background()
+	c, err := dialogflow.NewSessionEntityTypesClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.DeleteSessionEntityTypeRequest{
+		// TODO: Fill request struct fields.
+	}
+	err = c.DeleteSessionEntityType(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+}

vendor/cloud.google.com/go/dialogflow/apiv2/sessions_client.go

@@ -0,0 +1,142 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow
+
+import (
+	"cloud.google.com/go/internal/version"
+	gax "github.com/googleapis/gax-go"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+)
+
+// SessionsCallOptions contains the retry settings for each method of SessionsClient.
+type SessionsCallOptions struct {
+	DetectIntent          []gax.CallOption
+	StreamingDetectIntent []gax.CallOption
+}
+
+func defaultSessionsClientOptions() []option.ClientOption {
+	return []option.ClientOption{
+		option.WithEndpoint("dialogflow.googleapis.com:443"),
+		option.WithScopes(DefaultAuthScopes()...),
+	}
+}
+
+func defaultSessionsCallOptions() *SessionsCallOptions {
+	retry := map[[2]string][]gax.CallOption{}
+	return &SessionsCallOptions{
+		DetectIntent:          retry[[2]string{"default", "non_idempotent"}],
+		StreamingDetectIntent: retry[[2]string{"default", "non_idempotent"}],
+	}
+}
+
+// SessionsClient is a client for interacting with Dialogflow API.
+type SessionsClient struct {
+	// The connection to the service.
+	conn *grpc.ClientConn
+
+	// The gRPC API client.
+	sessionsClient dialogflowpb.SessionsClient
+
+	// The call options for this service.
+	CallOptions *SessionsCallOptions
+
+	// The x-goog-* metadata to be sent with each request.
+	xGoogMetadata metadata.MD
+}
+
+// NewSessionsClient creates a new sessions client.
+//
+// A session represents an interaction with a user. You retrieve user input
+// and pass it to the [DetectIntent][google.cloud.dialogflow.v2.Sessions.DetectIntent] (or
+// [StreamingDetectIntent][google.cloud.dialogflow.v2.Sessions.StreamingDetectIntent]) method to determine
+// user intent and respond.
+func NewSessionsClient(ctx context.Context, opts ...option.ClientOption) (*SessionsClient, error) {
+	conn, err := transport.DialGRPC(ctx, append(defaultSessionsClientOptions(), opts...)...)
+	if err != nil {
+		return nil, err
+	}
+	c := &SessionsClient{
+		conn:        conn,
+		CallOptions: defaultSessionsCallOptions(),
+
+		sessionsClient: dialogflowpb.NewSessionsClient(conn),
+	}
+	c.setGoogleClientInfo()
+	return c, nil
+}
+
+// Connection returns the client's connection to the API service.
+func (c *SessionsClient) Connection() *grpc.ClientConn {
+	return c.conn
+}
+
+// Close closes the connection to the API service. The user should invoke this when
+// the client is no longer required.
+func (c *SessionsClient) Close() error {
+	return c.conn.Close()
+}
+
+// setGoogleClientInfo sets the name and version of the application in
+// the `x-goog-api-client` header passed on each request. Intended for
+// use by Google-written clients.
+func (c *SessionsClient) setGoogleClientInfo(keyval ...string) {
+	kv := append([]string{"gl-go", version.Go()}, keyval...)
+	kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version)
+	c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...))
+}
+
+// DetectIntent processes a natural language query and returns structured, actionable data
+// as a result. This method is not idempotent, because it may cause contexts
+// and session entity types to be updated, which in turn might affect
+// results of future queries.
+func (c *SessionsClient) DetectIntent(ctx context.Context, req *dialogflowpb.DetectIntentRequest, opts ...gax.CallOption) (*dialogflowpb.DetectIntentResponse, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.DetectIntent[0:len(c.CallOptions.DetectIntent):len(c.CallOptions.DetectIntent)], opts...)
+	var resp *dialogflowpb.DetectIntentResponse
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.sessionsClient.DetectIntent(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// StreamingDetectIntent processes a natural language query in audio format in a streaming fashion
+// and returns structured, actionable data as a result. This method is only
+// available via the gRPC API (not REST).
+func (c *SessionsClient) StreamingDetectIntent(ctx context.Context, opts ...gax.CallOption) (dialogflowpb.Sessions_StreamingDetectIntentClient, error) {
+	ctx = insertMetadata(ctx, c.xGoogMetadata)
+	opts = append(c.CallOptions.StreamingDetectIntent[0:len(c.CallOptions.StreamingDetectIntent):len(c.CallOptions.StreamingDetectIntent)], opts...)
+	var resp dialogflowpb.Sessions_StreamingDetectIntentClient
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.sessionsClient.StreamingDetectIntent(ctx, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}

vendor/cloud.google.com/go/dialogflow/apiv2/sessions_client_example_test.go

@@ -0,0 +1,87 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package dialogflow_test
+
+import (
+	"io"
+
+	"cloud.google.com/go/dialogflow/apiv2"
+	"golang.org/x/net/context"
+	dialogflowpb "google.golang.org/genproto/googleapis/cloud/dialogflow/v2"
+)
+
+func ExampleNewSessionsClient() {
+	ctx := context.Background()
+	c, err := dialogflow.NewSessionsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use client.
+	_ = c
+}
+
+func ExampleSessionsClient_DetectIntent() {
+	ctx := context.Background()
+	c, err := dialogflow.NewSessionsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &dialogflowpb.DetectIntentRequest{
+		// TODO: Fill request struct fields.
+	}
+	resp, err := c.DetectIntent(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleSessionsClient_StreamingDetectIntent() {
+	ctx := context.Background()
+	c, err := dialogflow.NewSessionsClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	stream, err := c.StreamingDetectIntent(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	go func() {
+		reqs := []*dialogflowpb.StreamingDetectIntentRequest{
+			// TODO: Create requests.
+		}
+		for _, req := range reqs {
+			if err := stream.Send(req); err != nil {
+				// TODO: Handle error.
+			}
+		}
+		stream.CloseSend()
+	}()
+	for {
+		resp, err := stream.Recv()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			// TODO: handle error.
+		}
+		// TODO: Use resp.
+		_ = resp
+	}
+}